kenobi-pages 0.1.2 → 0.1.4

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+import type { KenobiPagesClient, KenobiPagesConfig } from "./types";
+export declare const createKenobiPagesClient: (config: KenobiPagesConfig) => KenobiPagesClient;

package/dist/client.js

@@ -0,0 +1 @@
+var l=Object.defineProperty;var o=(n,s)=>l(n,"name",{value:s,configurable:!0});import{KenobiPagesError as m,KenobiNotFoundError as p,KenobiUnauthorizedError as b}from"./errors";const d="https://kenobi.ai",t=o(async(n,s,e)=>{const i=`${(n.baseUrl??d).replace(/\/+$/,"")}${s}`,u={"x-kenobi-key":n.apiKey,"Content-Type":"application/json"},c={method:e?.method??"GET",headers:u};e?.body!==void 0&&(c.body=JSON.stringify(e.body)),(e?.revalidate!==void 0||e?.tags)&&(c.next={},e.revalidate!==void 0&&(c.next.revalidate=e.revalidate),e.tags&&(c.next.tags=[...e.tags]));const a=await fetch(i,c);if(a.ok)return a;if(a.status===401)throw new b;if(a.status===404)throw new p;const w=await a.text().catch(()=>"Unknown error");throw new m(`Kenobi API error (${a.status}): ${w}`,a.status,"API_ERROR")},"fetchFromKenobi"),f=o(n=>({getPage:o(async(s,e,r)=>{try{return await(await t(n,`/api/v1/pages/${s}/${e}`,r)).json()}catch(i){if(i instanceof p)return null;throw i}},"getPage"),getSchema:o(async(s,e)=>await(await t(n,`/api/v1/pages/${s}/schema`,e)).json(),"getSchema"),postSchema:o(async(s,e)=>await(await t(n,"/api/v1/pages/schema",{method:"POST",body:{name:s,schema:e}})).json(),"postSchema"),listWorkflows:o(async()=>(await(await t(n,"/api/v1/workflows")).json()).workflows,"listWorkflows"),getWorkflow:o(async s=>await(await t(n,`/api/v1/workflows/${s}`)).json(),"getWorkflow"),triggerRun:o(async(s,e)=>await(await t(n,`/api/v1/workflows/${s}/run`,{method:"POST",body:{params:e}})).json(),"triggerRun"),getRunStatus:o(async(s,e)=>await(await t(n,`/api/v1/workflows/${s}/runs/${e}`)).json(),"getRunStatus")}),"createKenobiPagesClient");export{f as createKenobiPagesClient};

package/dist/errors.d.ts

@@ -0,0 +1,11 @@
+export declare class KenobiPagesError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(message: string, status: number, code: string);
+}
+export declare class KenobiNotFoundError extends KenobiPagesError {
+    constructor(message?: string);
+}
+export declare class KenobiUnauthorizedError extends KenobiPagesError {
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1 @@
+var u=Object.defineProperty;var e=(o,r)=>u(o,"name",{value:r,configurable:!0});class s extends Error{static{e(this,"KenobiPagesError")}status;code;constructor(r,t,n){super(r),this.name="KenobiPagesError",this.status=t,this.code=n}}class a extends s{static{e(this,"KenobiNotFoundError")}constructor(r="Resource not found"){super(r,404,"NOT_FOUND"),this.name="KenobiNotFoundError"}}class c extends s{static{e(this,"KenobiUnauthorizedError")}constructor(r="Unauthorized \u2014 check your API key"){super(r,401,"UNAUTHORIZED"),this.name="KenobiUnauthorizedError"}}export{a as KenobiNotFoundError,s as KenobiPagesError,c as KenobiUnauthorizedError};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createKenobiPagesClient } from "./client";
+export { KenobiPagesError, KenobiNotFoundError, KenobiUnauthorizedError } from "./errors";
+export type { KenobiPagesClient, KenobiPagesConfig, KenobiFetchOptions, KenobiPageResponse, KenobiPageSchema, KenobiSchemaResponse, OutputFieldSpec, PostSchemaResponse, RunHandle, RunStatus, RunStatusResponse, WorkflowDetail, WorkflowParam, WorkflowSummary, } from "./types";

package/dist/index.js

@@ -0,0 +1 @@
+import{createKenobiPagesClient as n}from"./client";import{KenobiPagesError as t,KenobiNotFoundError as a,KenobiUnauthorizedError as i}from"./errors";export{a as KenobiNotFoundError,t as KenobiPagesError,i as KenobiUnauthorizedError,n as createKenobiPagesClient};

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+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;
+}
+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[];
+}
+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;
+}
+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>>;
+}
+export interface WorkflowParam {
+    readonly name: string;
+    readonly description?: string;
+}
+export interface WorkflowSummary {
+    readonly id: number;
+    readonly name: string;
+    readonly slug: string;
+    readonly params: readonly WorkflowParam[];
+    readonly outputProvider: string | null;
+    readonly outputTitle: string | null;
+}
+export interface WorkflowDetail {
+    readonly id: number;
+    readonly name: string;
+    readonly slug: string;
+    readonly params: readonly WorkflowParam[];
+    readonly output: {
+        readonly provider: string | null;
+        readonly title: string | null;
+        readonly schema: Record<string, unknown> | null;
+    };
+    readonly destinations: readonly {
+        readonly adapter: string;
+    }[];
+}
+export interface RunHandle {
+    readonly runId: string;
+    readonly status: string;
+}
+export type RunStatus = "QUEUED" | "EXECUTING" | "COMPLETED" | "FAILED" | "CANCELED";
+export interface RunStatusResponse {
+    readonly runId: string;
+    readonly status: RunStatus;
+    readonly output: Record<string, unknown> | null;
+    readonly createdAt: string;
+    readonly finishedAt: string | null;
+}
+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>;
+    readonly listWorkflows: () => Promise<readonly WorkflowSummary[]>;
+    readonly getWorkflow: (workflowId: number) => Promise<WorkflowDetail>;
+    readonly triggerRun: (workflowId: number, params: Record<string, string>) => Promise<RunHandle>;
+    readonly getRunStatus: (workflowId: number, runId: string) => Promise<RunStatusResponse>;
+}
+export {};

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "kenobi-pages",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Kenobi Pages SDK — fetch personalized page content from Kenobi workflows",
   "type": "module",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
   "bin": {
     "kenobi-pages": "./bin/cli.mjs"
   },
   "files": [
     "bin",
-    "src"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"

package/src/build.ts

@@ -1,50 +0,0 @@
-#!/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

@@ -1,472 +0,0 @@
-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)
-}
-
-// ── Run workflow ──
-
-const TERMINAL_STATUSES = new Set(["COMPLETED", "FAILED", "CANCELED", "SYSTEM_FAILURE", "CRASHED"])
-
-const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms))
-
-const runWorkflow = async (args: string[]) => {
-  const workflowId = args[0]
-  if (!workflowId) {
-    console.error("Usage: kenobi-pages run <workflowId> [--params '<json>']")
-    process.exit(2)
-  }
-
-  const remaining = args.slice(1)
-  const paramsIdx = remaining.indexOf("--params")
-  let params: Record<string, string> = {}
-  if (paramsIdx !== -1 && remaining[paramsIdx + 1]) {
-    try {
-      params = JSON.parse(remaining[paramsIdx + 1]) as Record<string, string>
-    } catch {
-      console.error("Error: Invalid JSON in --params")
-      process.exit(2)
-    }
-  }
-
-  const handle = (await fetchKenobi(`/api/v1/workflows/${workflowId}/run`, {
-    method: "POST",
-    body: { params },
-  })) as { runId: string; status: string }
-
-  console.error(`Run triggered: ${handle.runId}`)
-  console.error("Polling for completion...")
-
-  let delay = 2000
-  const MAX_DELAY = 15000
-
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    await sleep(delay)
-    const status = (await fetchKenobi(
-      `/api/v1/workflows/${workflowId}/runs/${handle.runId}`
-    )) as { runId: string; status: string; output?: unknown; finishedAt?: string }
-
-    console.error(`  Status: ${status.status}`)
-
-    if (TERMINAL_STATUSES.has(status.status)) {
-      console.log(JSON.stringify(status, null, 2))
-      if (status.status !== "COMPLETED") process.exit(1)
-      return
-    }
-
-    delay = Math.min(delay * 1.5, MAX_DELAY)
-  }
-}
-
-const listWorkflows = async () => {
-  const data = (await fetchKenobi("/api/v1/workflows")) as {
-    workflows: Array<{
-      id: number
-      name: string
-      slug: string
-      params: Array<{ name: string; description?: string }>
-    }>
-  }
-
-  console.log(JSON.stringify(data, null, 2))
-}
-
-// ── 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
-  kenobi-pages workflows                         List workflows for your org
-  kenobi-pages run <workflowId> [--params '{}']  Trigger a workflow run and poll to completion
-
-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
-  npx kenobi-pages workflows
-  npx kenobi-pages run 42 --params '{"slug":"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 if (group === "workflows") {
-  await listWorkflows()
-} else if (group === "run") {
-  await runWorkflow([action, ...rest].filter(Boolean))
-} else {
-  console.error(`Unknown command: ${argv.join(" ")}`)
-  console.error("Run 'kenobi-pages --help' for usage.")
-  process.exit(1)
-}

package/src/client.ts

@@ -1,127 +0,0 @@
-import { KenobiPagesError, KenobiNotFoundError, KenobiUnauthorizedError } from "./errors"
-import type {
-  KenobiPagesClient,
-  KenobiPagesConfig,
-  KenobiFetchOptions,
-  KenobiPageResponse,
-  KenobiPageSchema,
-  KenobiSchemaResponse,
-  PostSchemaResponse,
-  RunHandle,
-  RunStatusResponse,
-  WorkflowDetail,
-  WorkflowSummary,
-} 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
-  },
-
-  listWorkflows: async (): Promise<readonly WorkflowSummary[]> => {
-    const response = await fetchFromKenobi(config, "/api/v1/workflows")
-    const data = (await response.json()) as { workflows: WorkflowSummary[] }
-    return data.workflows
-  },
-
-  getWorkflow: async (workflowId: number): Promise<WorkflowDetail> => {
-    const response = await fetchFromKenobi(config, `/api/v1/workflows/${workflowId}`)
-    return (await response.json()) as WorkflowDetail
-  },
-
-  triggerRun: async (workflowId: number, params: Record<string, string>): Promise<RunHandle> => {
-    const response = await fetchFromKenobi(config, `/api/v1/workflows/${workflowId}/run`, {
-      method: "POST",
-      body: { params },
-    })
-    return (await response.json()) as RunHandle
-  },
-
-  getRunStatus: async (workflowId: number, runId: string): Promise<RunStatusResponse> => {
-    const response = await fetchFromKenobi(
-      config,
-      `/api/v1/workflows/${workflowId}/runs/${runId}`
-    )
-    return (await response.json()) as RunStatusResponse
-  },
-})

package/src/errors.ts

@@ -1,25 +0,0 @@
-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

@@ -1,18 +0,0 @@
-export { createKenobiPagesClient } from "./client"
-export { KenobiPagesError, KenobiNotFoundError, KenobiUnauthorizedError } from "./errors"
-export type {
-  KenobiPagesClient,
-  KenobiPagesConfig,
-  KenobiFetchOptions,
-  KenobiPageResponse,
-  KenobiPageSchema,
-  KenobiSchemaResponse,
-  OutputFieldSpec,
-  PostSchemaResponse,
-  RunHandle,
-  RunStatus,
-  RunStatusResponse,
-  WorkflowDetail,
-  WorkflowParam,
-  WorkflowSummary,
-} from "./types"

package/src/types.ts

@@ -1,132 +0,0 @@
-// ── 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>>
-}
-
-// ── Workflow types ──
-
-export interface WorkflowParam {
-  readonly name: string
-  readonly description?: string
-}
-
-export interface WorkflowSummary {
-  readonly id: number
-  readonly name: string
-  readonly slug: string
-  readonly params: readonly WorkflowParam[]
-  readonly outputProvider: string | null
-  readonly outputTitle: string | null
-}
-
-export interface WorkflowDetail {
-  readonly id: number
-  readonly name: string
-  readonly slug: string
-  readonly params: readonly WorkflowParam[]
-  readonly output: {
-    readonly provider: string | null
-    readonly title: string | null
-    readonly schema: Record<string, unknown> | null
-  }
-  readonly destinations: readonly { readonly adapter: string }[]
-}
-
-export interface RunHandle {
-  readonly runId: string
-  readonly status: string
-}
-
-export type RunStatus = "QUEUED" | "EXECUTING" | "COMPLETED" | "FAILED" | "CANCELED"
-
-export interface RunStatusResponse {
-  readonly runId: string
-  readonly status: RunStatus
-  readonly output: Record<string, unknown> | null
-  readonly createdAt: string
-  readonly finishedAt: string | null
-}
-
-// ── 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>
-  readonly listWorkflows: () => Promise<readonly WorkflowSummary[]>
-  readonly getWorkflow: (workflowId: number) => Promise<WorkflowDetail>
-  readonly triggerRun: (workflowId: number, params: Record<string, string>) => Promise<RunHandle>
-  readonly getRunStatus: (workflowId: number, runId: string) => Promise<RunStatusResponse>
-}