kenobi-pages 0.1.1

package/bin/cli.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+var C=Object.defineProperty;var t=(e,o)=>C(e,"name",{value:o,configurable:!0});import{existsSync as P,mkdirSync as F,readFileSync as E,writeFileSync as I,appendFileSync as G}from"node:fs";import{readFile as j}from"node:fs/promises";import{homedir as L}from"node:os";import{join as _,resolve as x}from"node:path";import{createInterface as R}from"node:readline";var U="https://kenobi.ai",v=_(L(),".kenobi"),S=_(v,"config.json"),l="KENOBI_PAGES_KEY",$=t(()=>{try{return JSON.parse(E(S,"utf-8"))}catch{return{}}},"readGlobalConfig"),B=t(e=>{F(v,{recursive:!0}),I(S,JSON.stringify(e,null,2)+`
+`)},"writeGlobalConfig"),J=t(()=>{let e=process.env[l]||$().apiKey;return e||(console.error("Error: No API key found."),console.error(""),console.error("Run 'npx kenobi-pages init' to set up your API key."),console.error(""),console.error("Or set the KENOBI_PAGES_KEY environment variable directly."),process.exit(1)),e},"getApiKey"),T=t(()=>(process.env.KENOBI_BASE_URL??$().baseUrl??U).replace(/\/+$/,""),"getBaseUrl"),k=t(async(e,o={})=>{let n=`${T()}${e}`,s=await fetch(n,{method:o.method??"GET",headers:{"x-kenobi-key":J(),"Content-Type":"application/json"},body:o.body?JSON.stringify(o.body):void 0});if(!s.ok){let r=await s.text().catch(()=>"Unknown error"),i=s.status===401||s.status===403?4:s.status===404?3:1;console.error(`Error ${s.status}: ${r}`),process.exit(i)}return s.json()},"fetchKenobi"),w=t(e=>new Promise(o=>{let n=R({input:process.stdin,output:process.stderr});n.question(e,s=>{n.close(),o(s.trim())})}),"prompt"),Y=t(()=>new Promise((e,o)=>{let n="";process.stdin.setEncoding("utf-8"),process.stdin.on("data",s=>{n+=s}),process.stdin.on("end",()=>e(n)),process.stdin.on("error",o),process.stdin.isTTY&&e("")}),"readStdin"),W=t(async e=>{let o=e.indexOf("--file");return o!==-1&&e[o+1]?j(e[o+1],"utf-8"):null},"parseFileArg"),D=t(async()=>{console.error("Kenobi Pages \u2014 Setup"),console.error(""),console.error("Find your Pages API key in the workflow builder:"),console.error("  https://kenobi.ai/testing/cortex"),console.error("");let e=await w("Paste your API key (pk_live_... or pk_test_...): ");e||(console.error("No key provided. Aborting."),process.exit(1)),!e.startsWith("pk_live_")&&!e.startsWith("pk_test_")&&(console.error(`Warning: "${e}" doesn't look like a Kenobi public key (expected pk_live_... or pk_test_...).`),(await w("Continue anyway? (y/N): ")).toLowerCase()!=="y"&&(console.error("Aborting."),process.exit(1)));let o=$();o.apiKey=e,B(o),console.error(`\u2713 Saved to ${S}`);let n=x(process.cwd(),".env.local"),s=x(process.cwd(),".env"),r=P(n)?n:P(s)?s:null;if(r){let i=E(r,"utf-8");if(i.includes(l))console.error(`\u2713 ${l} already present in ${r.split("/").pop()}`);else{let p=i.endsWith(`
+`)?"":`
+`;G(r,`${p}${l}="${e}"
+`),console.error(`\u2713 Added ${l} to ${r.split("/").pop()}`)}}else(await w("No .env.local found. Create one with your API key? (Y/n): ")).toLowerCase()!=="n"&&(I(n,`${l}="${e}"
+`),console.error(`\u2713 Created .env.local with ${l}`));console.error(""),console.error("Done! You can now use kenobi-pages commands."),console.error(`  npx kenobi-pages schema push "My Page" '{"fields":{...}}'`),console.error("  npx kenobi-pages types <workflowId>")},"initCommand"),M=t(async e=>{let o=e[0];o||(console.error("Usage: kenobi-pages schema get <workflowId>"),process.exit(2));let n=await k(`/api/v1/pages/${o}/schema`);console.log(JSON.stringify(n,null,2))},"schemaGet"),q=t(async e=>{let o=e[0];o||(console.error("Usage: kenobi-pages schema push <name> '<json>'"),console.error("       kenobi-pages schema push <name> --file schema.json"),console.error("       echo '<json>' | kenobi-pages schema push <name>"),process.exit(2));let n=e.slice(1),s=await W(n),r=s?null:n.find(b=>b.startsWith("{")),i=!s&&!r?await Y():null,p=s??r??i;(!p||p.trim().length===0)&&(console.error("Error: No schema provided."),console.error("Pass inline JSON, --file <path>, or pipe to stdin."),process.exit(2));let f;try{f=JSON.parse(p)}catch{console.error("Error: Invalid JSON."),process.exit(2)}let m=await k("/api/v1/pages/schema",{method:"POST",body:{name:o,schema:f}});console.log(JSON.stringify(m,null,2)),console.error(`Schema "${m.name}" pushed successfully.`),console.error(`Source key: ${m.sourceKey}`),console.error("You can now select this schema as an output target in the Kenobi workflow builder.")},"schemaPush"),z=t(async e=>{let[o,n]=e;(!o||!n)&&(console.error("Usage: kenobi-pages page get <workflowId> <slug>"),process.exit(2));let s=await k(`/api/v1/pages/${o}/${n}`);console.log(JSON.stringify(s,null,2))},"pageGet"),H=t(async e=>{let o=e[0];o||(console.error("Usage: kenobi-pages types <workflowId>"),process.exit(2));let n=await k(`/api/v1/pages/${o}/schema`),s=n.schema;s?.fields||(console.error("Error: Workflow has no output schema with fields."),process.exit(1));let r=t(a=>"  ".repeat(a),"indent"),i=t((a,c=1)=>{switch(a.type){case"string":case"url":return"string";case"number":return"number";case"boolean":return"boolean";case"enum":return a.values?.length?a.values.map(u=>`"${u}"`).join(" | "):"string";case"object":{let u=Object.entries(a.fields??{});return u.length===0?"Record<string, unknown>":`{
+${u.map(([N,O])=>{let K=O.optional?"?":"";return`${r(c)}${N}${K}: ${i(O,c+1)}`}).join(`
+`)}
+${r(c-1)}}`}case"array":return`Array<${i(a.items,c)}>`;default:return"unknown"}},"fieldToTs"),f=Object.entries(s.fields).map(([a,c])=>{let u=c.optional?"?":"";return`${c.description?`  /** ${c.description} */
+`:""}  ${a}${u}: ${i(c,2)}`}),b=`export interface ${n.title?n.title.replace(/[^a-zA-Z0-9]+/g,""):"PageContent"} {
+${f.join(`
+`)}
+}
+`;console.log(b)},"typesGen"),V=`kenobi-pages \u2014 Kenobi Pages CLI
+
+Commands:
+  kenobi-pages init                              Set up your API key (interactive)
+  kenobi-pages schema get <workflowId>           Fetch a workflow's output schema
+  kenobi-pages schema push <name> '<json>'       Push a schema to Kenobi (inline JSON)
+  kenobi-pages schema push <name> --file f       Push a schema to Kenobi (from file)
+  kenobi-pages page get <workflowId> <slug>      Fetch page content for a specific lead
+  kenobi-pages types <workflowId>                Generate TypeScript interface from schema
+
+Examples:
+  npx kenobi-pages init
+  npx kenobi-pages schema get 42
+  npx kenobi-pages schema push "My Page" '{"fields":{"headline":{"type":"string"}}}'
+  npx kenobi-pages types 42 > lib/kenobi-types.ts
+  npx kenobi-pages page get 42 acme-corp
+
+Output:
+  All data is written as JSON to stdout. Status messages go to stderr.
+  Pipe stdout to jq, a file, or another command safely.
+
+Exit codes:
+  0   Success
+  1   API or network error
+  2   Invalid usage (bad arguments)
+  3   Resource not found (404)
+  4   Unauthorized (invalid API key)
+
+Environment:
+  KENOBI_PAGES_KEY       Org public key. Set via 'init' or manually.
+  KENOBI_BASE_URL      Optional. Override the Kenobi API base URL.
+
+Key resolution order:
+  1. KENOBI_PAGES_KEY environment variable
+  2. ~/.kenobi/config.json (written by 'init')
+`,[,,...d]=process.argv;(d.length===0||d[0]==="--help"||d[0]==="-h")&&(console.log(V),process.exit(0));var[g,h,...y]=d;g==="init"?await D():g==="schema"&&h==="get"?await M(y):g==="schema"&&h==="push"?await q(y):g==="page"&&h==="get"?await z(y):g==="types"?await H([h,...y]):(console.error(`Unknown command: ${d.join(" ")}`),console.error("Run 'kenobi-pages --help' for usage."),process.exit(1));

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "kenobi-pages",
+  "version": "0.1.1",
+  "description": "Kenobi Pages SDK — fetch personalized page content from Kenobi workflows",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "bin": {
+    "kenobi-pages": "./bin/cli.mjs"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsx src/build.ts --prod",
+    "bump": "pnpm version patch",
+    "lint": "eslint src/",
+    "tsc": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.28.0",
+    "@types/node": "catalog:",
+    "esbuild": "^0.25.9",
+    "eslint": "catalog:",
+    "eslint-config-prettier": "^10.1.5",
+    "tsx": "^4.21.0",
+    "typescript": "catalog:",
+    "typescript-eslint": "^8.34.0"
+  }
+}

package/src/build.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env tsx
+
+import * as fs from "fs"
+import * as path from "path"
+
+import * as esbuild from "esbuild"
+
+const isProd =
+  process.argv.includes("--prod") || process.env.NODE_ENV === "production"
+
+const packageJsonPath = path.join(process.cwd(), "package.json")
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"))
+const version = packageJson.version as string
+
+const entryFile = path.join(process.cwd(), "src", "cli.ts")
+const outFile = path.join(process.cwd(), "bin", "cli.mjs")
+
+const build = async () => {
+  console.log(
+    `📦 Building CLI ${isProd ? "(production)" : "(development)"} v${version}...`
+  )
+
+  const result = await esbuild.build({
+    entryPoints: [entryFile],
+    bundle: true,
+    platform: "node",
+    target: ["node18"],
+    format: "esm",
+    treeShaking: true,
+    minify: isProd,
+    keepNames: true,
+    metafile: true,
+    logLevel: "info",
+    outfile: outFile,
+    banner: {
+      js: "#!/usr/bin/env node",
+    },
+  })
+
+  if (result.metafile) {
+    const outputs = Object.values(result.metafile.outputs)
+    const totalSize = outputs.reduce((acc, output) => acc + output.bytes, 0)
+    console.log(`\n✅ Build complete: ${(totalSize / 1024).toFixed(2)} KB → ${outFile}`)
+  }
+}
+
+build().catch((error) => {
+  console.error("Build failed:", error)
+  process.exit(1)
+})

package/src/cli.ts

@@ -0,0 +1,396 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+} from "node:fs"
+import { readFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import { join, resolve } from "node:path"
+import { createInterface } from "node:readline"
+
+const DEFAULT_BASE_URL = "https://kenobi.ai"
+const GLOBAL_CONFIG_DIR = join(homedir(), ".kenobi")
+const GLOBAL_CONFIG_PATH = join(GLOBAL_CONFIG_DIR, "config.json")
+const ENV_VAR_NAME = "KENOBI_PAGES_KEY"
+
+// ── Types ──
+
+interface GlobalConfig {
+  apiKey?: string
+  baseUrl?: string
+}
+
+interface FetchOptions {
+  method?: string
+  body?: Record<string, unknown>
+}
+
+interface OutputFieldSpec {
+  type: string
+  optional?: boolean
+  description?: string
+  values?: string[]
+  fields?: Record<string, OutputFieldSpec>
+  items?: OutputFieldSpec
+}
+
+// ── Global config ──
+
+const readGlobalConfig = (): GlobalConfig => {
+  try {
+    return JSON.parse(readFileSync(GLOBAL_CONFIG_PATH, "utf-8")) as GlobalConfig
+  } catch {
+    return {}
+  }
+}
+
+const writeGlobalConfig = (config: GlobalConfig) => {
+  mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true })
+  writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n")
+}
+
+// ── Helpers ──
+
+const getApiKey = (): string => {
+  const key = process.env[ENV_VAR_NAME] || readGlobalConfig().apiKey
+  if (!key) {
+    console.error("Error: No API key found.")
+    console.error("")
+    console.error("Run 'npx kenobi-pages init' to set up your API key.")
+    console.error("")
+    console.error("Or set the KENOBI_PAGES_KEY environment variable directly.")
+    process.exit(1)
+  }
+  return key
+}
+
+const getBaseUrl = (): string =>
+  (
+    process.env.KENOBI_BASE_URL ??
+    readGlobalConfig().baseUrl ??
+    DEFAULT_BASE_URL
+  ).replace(/\/+$/, "")
+
+const fetchKenobi = async (path: string, opts: FetchOptions = {}) => {
+  const url = `${getBaseUrl()}${path}`
+  const res = await fetch(url, {
+    method: opts.method ?? "GET",
+    headers: {
+      "x-kenobi-key": getApiKey(),
+      "Content-Type": "application/json",
+    },
+    body: opts.body ? JSON.stringify(opts.body) : undefined,
+  })
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => "Unknown error")
+    const exitCode =
+      res.status === 401 || res.status === 403
+        ? 4
+        : res.status === 404
+          ? 3
+          : 1
+    console.error(`Error ${res.status}: ${text}`)
+    process.exit(exitCode)
+  }
+
+  return res.json()
+}
+
+const prompt = (question: string): Promise<string> =>
+  new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stderr })
+    rl.question(question, (answer) => {
+      rl.close()
+      resolve(answer.trim())
+    })
+  })
+
+const readStdin = (): Promise<string> =>
+  new Promise((resolve, reject) => {
+    let data = ""
+    process.stdin.setEncoding("utf-8")
+    process.stdin.on("data", (chunk: string) => {
+      data += chunk
+    })
+    process.stdin.on("end", () => resolve(data))
+    process.stdin.on("error", reject)
+    if (process.stdin.isTTY) resolve("")
+  })
+
+const parseFileArg = async (args: string[]): Promise<string | null> => {
+  const fileIdx = args.indexOf("--file")
+  if (fileIdx !== -1 && args[fileIdx + 1]) {
+    return readFile(args[fileIdx + 1], "utf-8")
+  }
+  return null
+}
+
+// ── Init ──
+
+const initCommand = async () => {
+  console.error("Kenobi Pages — Setup")
+  console.error("")
+  console.error("Find your Pages API key in the workflow builder:")
+  console.error("  https://kenobi.ai/testing/cortex")
+  console.error("")
+
+  const key = await prompt("Paste your API key (pk_live_... or pk_test_...): ")
+
+  if (!key) {
+    console.error("No key provided. Aborting.")
+    process.exit(1)
+  }
+
+  if (!key.startsWith("pk_live_") && !key.startsWith("pk_test_")) {
+    console.error(
+      `Warning: "${key}" doesn't look like a Kenobi public key (expected pk_live_... or pk_test_...).`
+    )
+    const proceed = await prompt("Continue anyway? (y/N): ")
+    if (proceed.toLowerCase() !== "y") {
+      console.error("Aborting.")
+      process.exit(1)
+    }
+  }
+
+  const config = readGlobalConfig()
+  config.apiKey = key
+  writeGlobalConfig(config)
+  console.error(`✓ Saved to ${GLOBAL_CONFIG_PATH}`)
+
+  const envLocalPath = resolve(process.cwd(), ".env.local")
+  const envPath = resolve(process.cwd(), ".env")
+  const targetEnvFile = existsSync(envLocalPath)
+    ? envLocalPath
+    : existsSync(envPath)
+      ? envPath
+      : null
+
+  if (targetEnvFile) {
+    const contents = readFileSync(targetEnvFile, "utf-8")
+    if (contents.includes(ENV_VAR_NAME)) {
+      console.error(
+        `✓ ${ENV_VAR_NAME} already present in ${targetEnvFile.split("/").pop()}`
+      )
+    } else {
+      const suffix = contents.endsWith("\n") ? "" : "\n"
+      appendFileSync(targetEnvFile, `${suffix}${ENV_VAR_NAME}="${key}"\n`)
+      console.error(
+        `✓ Added ${ENV_VAR_NAME} to ${targetEnvFile.split("/").pop()}`
+      )
+    }
+  } else {
+    const createEnvLocal = await prompt(
+      "No .env.local found. Create one with your API key? (Y/n): "
+    )
+    if (createEnvLocal.toLowerCase() !== "n") {
+      writeFileSync(envLocalPath, `${ENV_VAR_NAME}="${key}"\n`)
+      console.error(`✓ Created .env.local with ${ENV_VAR_NAME}`)
+    }
+  }
+
+  console.error("")
+  console.error("Done! You can now use kenobi-pages commands.")
+  console.error(
+    '  npx kenobi-pages schema push "My Page" \'{"fields":{...}}\''
+  )
+  console.error("  npx kenobi-pages types <workflowId>")
+}
+
+// ── Subcommands ──
+
+const schemaGet = async (args: string[]) => {
+  const workflowId = args[0]
+  if (!workflowId) {
+    console.error("Usage: kenobi-pages schema get <workflowId>")
+    process.exit(2)
+  }
+
+  const data = await fetchKenobi(`/api/v1/pages/${workflowId}/schema`)
+  console.log(JSON.stringify(data, null, 2))
+}
+
+const schemaPush = async (args: string[]) => {
+  const name = args[0]
+  if (!name) {
+    console.error("Usage: kenobi-pages schema push <name> '<json>'")
+    console.error("       kenobi-pages schema push <name> --file schema.json")
+    console.error("       echo '<json>' | kenobi-pages schema push <name>")
+    process.exit(2)
+  }
+
+  const remaining = args.slice(1)
+  const fileContent = await parseFileArg(remaining)
+
+  const inlineArg = !fileContent
+    ? remaining.find((a) => a.startsWith("{"))
+    : null
+  const stdinContent = !fileContent && !inlineArg ? await readStdin() : null
+  const rawJson = fileContent ?? inlineArg ?? stdinContent
+
+  if (!rawJson || rawJson.trim().length === 0) {
+    console.error("Error: No schema provided.")
+    console.error("Pass inline JSON, --file <path>, or pipe to stdin.")
+    process.exit(2)
+  }
+
+  let schema: Record<string, unknown>
+  try {
+    schema = JSON.parse(rawJson) as Record<string, unknown>
+  } catch {
+    console.error("Error: Invalid JSON.")
+    process.exit(2)
+  }
+
+  const data = (await fetchKenobi("/api/v1/pages/schema", {
+    method: "POST",
+    body: { name, schema },
+  })) as { name: string; sourceKey: string }
+
+  console.log(JSON.stringify(data, null, 2))
+  console.error(`Schema "${data.name}" pushed successfully.`)
+  console.error(`Source key: ${data.sourceKey}`)
+  console.error(
+    "You can now select this schema as an output target in the Kenobi workflow builder."
+  )
+}
+
+const pageGet = async (args: string[]) => {
+  const [workflowId, slug] = args
+  if (!workflowId || !slug) {
+    console.error("Usage: kenobi-pages page get <workflowId> <slug>")
+    process.exit(2)
+  }
+
+  const data = await fetchKenobi(`/api/v1/pages/${workflowId}/${slug}`)
+  console.log(JSON.stringify(data, null, 2))
+}
+
+const typesGen = async (args: string[]) => {
+  const workflowId = args[0]
+  if (!workflowId) {
+    console.error("Usage: kenobi-pages types <workflowId>")
+    process.exit(2)
+  }
+
+  const data = (await fetchKenobi(
+    `/api/v1/pages/${workflowId}/schema`
+  )) as { schema: { fields?: Record<string, OutputFieldSpec> }; title?: string }
+  const schema = data.schema
+
+  if (!schema?.fields) {
+    console.error("Error: Workflow has no output schema with fields.")
+    process.exit(1)
+  }
+
+  const indent = (level: number) => "  ".repeat(level)
+
+  const fieldToTs = (spec: OutputFieldSpec, level = 1): string => {
+    switch (spec.type) {
+      case "string":
+      case "url":
+        return "string"
+      case "number":
+        return "number"
+      case "boolean":
+        return "boolean"
+      case "enum":
+        return spec.values?.length
+          ? spec.values.map((v) => `"${v}"`).join(" | ")
+          : "string"
+      case "object": {
+        const entries = Object.entries(spec.fields ?? {})
+        if (entries.length === 0) return "Record<string, unknown>"
+        const lines = entries.map(([k, v]) => {
+          const opt = v.optional ? "?" : ""
+          return `${indent(level)}${k}${opt}: ${fieldToTs(v, level + 1)}`
+        })
+        return `{\n${lines.join("\n")}\n${indent(level - 1)}}`
+      }
+      case "array":
+        return `Array<${fieldToTs(spec.items!, level)}>`
+      default:
+        return "unknown"
+    }
+  }
+
+  const entries = Object.entries(schema.fields)
+  const lines = entries.map(([k, v]) => {
+    const opt = v.optional ? "?" : ""
+    const comment = v.description ? `  /** ${v.description} */\n` : ""
+    return `${comment}  ${k}${opt}: ${fieldToTs(v, 2)}`
+  })
+
+  const typeName = data.title
+    ? data.title.replace(/[^a-zA-Z0-9]+/g, "")
+    : "PageContent"
+
+  const output = `export interface ${typeName} {\n${lines.join("\n")}\n}\n`
+  console.log(output)
+}
+
+// ── Router ──
+
+const HELP = `kenobi-pages — Kenobi Pages CLI
+
+Commands:
+  kenobi-pages init                              Set up your API key (interactive)
+  kenobi-pages schema get <workflowId>           Fetch a workflow's output schema
+  kenobi-pages schema push <name> '<json>'       Push a schema to Kenobi (inline JSON)
+  kenobi-pages schema push <name> --file f       Push a schema to Kenobi (from file)
+  kenobi-pages page get <workflowId> <slug>      Fetch page content for a specific lead
+  kenobi-pages types <workflowId>                Generate TypeScript interface from schema
+
+Examples:
+  npx kenobi-pages init
+  npx kenobi-pages schema get 42
+  npx kenobi-pages schema push "My Page" '{"fields":{"headline":{"type":"string"}}}'
+  npx kenobi-pages types 42 > lib/kenobi-types.ts
+  npx kenobi-pages page get 42 acme-corp
+
+Output:
+  All data is written as JSON to stdout. Status messages go to stderr.
+  Pipe stdout to jq, a file, or another command safely.
+
+Exit codes:
+  0   Success
+  1   API or network error
+  2   Invalid usage (bad arguments)
+  3   Resource not found (404)
+  4   Unauthorized (invalid API key)
+
+Environment:
+  KENOBI_PAGES_KEY       Org public key. Set via 'init' or manually.
+  KENOBI_BASE_URL      Optional. Override the Kenobi API base URL.
+
+Key resolution order:
+  1. KENOBI_PAGES_KEY environment variable
+  2. ~/.kenobi/config.json (written by 'init')
+`
+
+const [, , ...argv] = process.argv
+
+if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+  console.log(HELP)
+  process.exit(0)
+}
+
+const [group, action, ...rest] = argv
+
+if (group === "init") {
+  await initCommand()
+} else if (group === "schema" && action === "get") {
+  await schemaGet(rest)
+} else if (group === "schema" && action === "push") {
+  await schemaPush(rest)
+} else if (group === "page" && action === "get") {
+  await pageGet(rest)
+} else if (group === "types") {
+  await typesGen([action, ...rest])
+} else {
+  console.error(`Unknown command: ${argv.join(" ")}`)
+  console.error("Run 'kenobi-pages --help' for usage.")
+  process.exit(1)
+}

package/src/client.ts

@@ -0,0 +1,96 @@
+import { KenobiPagesError, KenobiNotFoundError, KenobiUnauthorizedError } from "./errors"
+import type {
+  KenobiPagesClient,
+  KenobiPagesConfig,
+  KenobiFetchOptions,
+  KenobiPageResponse,
+  KenobiPageSchema,
+  KenobiSchemaResponse,
+  PostSchemaResponse,
+} from "./types"
+
+const DEFAULT_BASE_URL = "https://kenobi.ai"
+
+// ── Internal fetch helper ──
+
+const fetchFromKenobi = async (
+  config: KenobiPagesConfig,
+  path: string,
+  opts?: KenobiFetchOptions & { method?: string; body?: unknown }
+): Promise<Response> => {
+  const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "")
+  const url = `${baseUrl}${path}`
+
+  const headers: Record<string, string> = {
+    "x-kenobi-key": config.apiKey,
+    "Content-Type": "application/json",
+  }
+
+  const fetchInit: RequestInit & { next?: { revalidate?: number | false; tags?: readonly string[] } } = {
+    method: opts?.method ?? "GET",
+    headers,
+  }
+
+  if (opts?.body !== undefined) {
+    fetchInit.body = JSON.stringify(opts.body)
+  }
+
+  if (opts?.revalidate !== undefined || opts?.tags) {
+    fetchInit.next = {}
+    if (opts.revalidate !== undefined) fetchInit.next.revalidate = opts.revalidate
+    if (opts.tags) fetchInit.next.tags = opts.tags
+  }
+
+  const response = await fetch(url, fetchInit)
+
+  if (response.ok) return response
+
+  if (response.status === 401) {
+    throw new KenobiUnauthorizedError()
+  }
+
+  if (response.status === 404) {
+    throw new KenobiNotFoundError()
+  }
+
+  const errorBody = await response.text().catch(() => "Unknown error")
+  throw new KenobiPagesError(
+    `Kenobi API error (${response.status}): ${errorBody}`,
+    response.status,
+    "API_ERROR"
+  )
+}
+
+// ── Client factory ──
+
+export const createKenobiPagesClient = (config: KenobiPagesConfig): KenobiPagesClient => ({
+  getPage: async (
+    workflowId: number,
+    slug: string,
+    opts?: KenobiFetchOptions
+  ): Promise<KenobiPageResponse | null> => {
+    try {
+      const response = await fetchFromKenobi(config, `/api/v1/pages/${workflowId}/${slug}`, opts)
+      return (await response.json()) as KenobiPageResponse
+    } catch (err) {
+      if (err instanceof KenobiNotFoundError) return null
+      throw err
+    }
+  },
+
+  getSchema: async (
+    workflowId: number,
+    opts?: KenobiFetchOptions
+  ): Promise<KenobiSchemaResponse> => {
+    const response = await fetchFromKenobi(config, `/api/v1/pages/${workflowId}/schema`, opts)
+    return (await response.json()) as KenobiSchemaResponse
+  },
+
+  postSchema: async (name: string, schema: KenobiPageSchema): Promise<PostSchemaResponse> => {
+    const response = await fetchFromKenobi(config, "/api/v1/pages/schema", {
+      method: "POST",
+      body: { name, schema },
+    })
+    return (await response.json()) as PostSchemaResponse
+  },
+})

package/src/errors.ts

@@ -0,0 +1,25 @@
+export class KenobiPagesError extends Error {
+  readonly status: number
+  readonly code: string
+
+  constructor(message: string, status: number, code: string) {
+    super(message)
+    this.name = "KenobiPagesError"
+    this.status = status
+    this.code = code
+  }
+}
+
+export class KenobiNotFoundError extends KenobiPagesError {
+  constructor(message = "Resource not found") {
+    super(message, 404, "NOT_FOUND")
+    this.name = "KenobiNotFoundError"
+  }
+}
+
+export class KenobiUnauthorizedError extends KenobiPagesError {
+  constructor(message = "Unauthorized — check your API key") {
+    super(message, 401, "UNAUTHORIZED")
+    this.name = "KenobiUnauthorizedError"
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export { createKenobiPagesClient } from "./client"
+export { KenobiPagesError, KenobiNotFoundError, KenobiUnauthorizedError } from "./errors"
+export type {
+  KenobiPagesClient,
+  KenobiPagesConfig,
+  KenobiFetchOptions,
+  KenobiPageResponse,
+  KenobiPageSchema,
+  KenobiSchemaResponse,
+  OutputFieldSpec,
+  PostSchemaResponse,
+} from "./types"

package/src/types.ts

@@ -0,0 +1,84 @@
+// ── Client configuration ──
+
+export interface KenobiPagesConfig {
+  /** Org-scoped public key from the Kenobi workflow builder (pk_live_... or pk_test_...). */
+  readonly apiKey: string
+  /** Base URL of the Kenobi API. Defaults to https://kenobi.ai */
+  readonly baseUrl?: string
+}
+
+// ── Next.js fetch options ──
+
+export interface KenobiFetchOptions {
+  /** Next.js ISR revalidation interval in seconds, or `false` to disable caching. */
+  readonly revalidate?: number | false
+  /** Next.js cache tags for on-demand revalidation via `revalidateTag()`. */
+  readonly tags?: readonly string[]
+}
+
+// ── API response types ──
+
+export interface KenobiPageResponse {
+  readonly content: Record<string, unknown>
+  readonly metadata: Record<string, unknown> | null
+  readonly updatedAt: string
+}
+
+export interface KenobiSchemaResponse {
+  readonly schema: Record<string, unknown>
+  readonly provider: string
+  readonly title: string
+}
+
+export interface PostSchemaResponse {
+  readonly sourceKey: string
+  readonly name: string
+}
+
+// ── Schema DSL types (standalone — no @kenobi/cortex dependency) ──
+
+interface FieldSpecBase {
+  readonly description?: string
+  readonly optional?: boolean
+}
+
+export type OutputFieldSpec =
+  | ({ readonly type: "string"; readonly min?: number; readonly max?: number } & FieldSpecBase)
+  | ({ readonly type: "url" } & FieldSpecBase)
+  | ({
+      readonly type: "number"
+      readonly min?: number
+      readonly max?: number
+      readonly integer?: boolean
+    } & FieldSpecBase)
+  | ({ readonly type: "boolean" } & FieldSpecBase)
+  | ({ readonly type: "enum"; readonly values?: readonly string[] } & FieldSpecBase)
+  | ({
+      readonly type: "object"
+      readonly fields: Readonly<Record<string, OutputFieldSpec>>
+    } & FieldSpecBase)
+  | ({
+      readonly type: "array"
+      readonly items: OutputFieldSpec
+      readonly min?: number
+      readonly max?: number
+    } & FieldSpecBase)
+
+export interface KenobiPageSchema {
+  readonly fields: Readonly<Record<string, OutputFieldSpec>>
+}
+
+// ── Client interface ──
+
+export interface KenobiPagesClient {
+  readonly getPage: (
+    workflowId: number,
+    slug: string,
+    opts?: KenobiFetchOptions
+  ) => Promise<KenobiPageResponse | null>
+  readonly getSchema: (
+    workflowId: number,
+    opts?: KenobiFetchOptions
+  ) => Promise<KenobiSchemaResponse>
+  readonly postSchema: (name: string, schema: KenobiPageSchema) => Promise<PostSchemaResponse>
+}