@seoblog/next 0.1.1 → 0.1.3

package/README.md

@@ -0,0 +1,234 @@
+# @seoblog/next
+
+The official Next.js SDK + CLI for [SEO Blog](https://www.nextseoblog.com) — an AI service that writes, schedules, and publishes SEO-optimized blog posts straight into your Next.js site.
+
+- **One-command setup** — `npx @seoblog/next setup` scaffolds an entire blog (index, post page, sitemap, RSS, JSON-LD) wired to your dashboard.
+- **App Router native** — uses Server Components, `generateMetadata`, `generateStaticParams`, and ISR.
+- **Typed API client** — `getPosts()` / `getPost(slug)` with full TypeScript types.
+- **Zero lock-in** — your content is plain Markdown; pull it any time.
+
+---
+
+## Quick start
+
+In the root of your Next.js app:
+
+```bash
+npx @seoblog/next setup
+```
+
+The CLI will:
+
+1. Detect your project (App Router, TypeScript, `src/` layout, Tailwind).
+2. Ask where the blog should live and a few SEO details.
+3. Scaffold:
+   - `app/blog/page.tsx` — listing
+   - `app/blog/[slug]/page.tsx` — post page with metadata + JSON-LD
+   - `app/blog/feed.xml/route.ts` — RSS feed
+   - `app/sitemap.ts` — sitemap that includes your posts
+   - `lib/seoblog.ts` — typed client reading `SEOBLOG_API_KEY` from env
+   - `.env.local` and `.env.example` entries
+4. Print the exact install command for your package manager.
+
+Then install the runtime deps it prints (typically `@seoblog/next marked`), paste your API key from the [dashboard](https://www.nextseoblog.com/dashboard) into `.env.local`, and visit `/blog`.
+
+> **Requirements:** Next.js 14+ with the App Router. Pages Router users can still use the API client manually — see below.
+
+---
+
+## Installation (manual)
+
+If you'd rather wire things up yourself:
+
+```bash
+npm install @seoblog/next
+```
+
+Set your API key in `.env.local`:
+
+```bash
+SEOBLOG_API_KEY=sk_live_...
+```
+
+Get the key from your [SEO Blog dashboard](https://www.nextseoblog.com/dashboard) → site → API Keys.
+
+---
+
+## API reference
+
+### `getPosts(options)`
+
+Returns every published post for the site bound to your API key, ordered by `publishedAt` descending.
+
+```ts
+import { getPosts } from "@seoblog/next";
+
+const posts = await getPosts({ apiKey: process.env.SEOBLOG_API_KEY! });
+```
+
+**Options**
+
+| Option       | Type                | Default                            | Description                                       |
+| ------------ | ------------------- | ---------------------------------- | ------------------------------------------------- |
+| `apiKey`     | `string` (required) | —                                  | Your site's API key.                              |
+| `apiUrl`     | `string`            | `"https://www.nextseoblog.com"`    | Override for self-hosting or local development.   |
+| `revalidate` | `number`            | `3600`                             | ISR revalidation in seconds. Pass `0` for `no-store`. |
+
+### `getPost(slug, options)`
+
+Returns a single post by slug, or `null` if not found.
+
+```ts
+import { getPost } from "@seoblog/next";
+
+const post = await getPost("my-first-post", {
+  apiKey: process.env.SEOBLOG_API_KEY!,
+});
+```
+
+### `BlogPost`
+
+```ts
+interface BlogPost {
+  id: string;
+  title: string;
+  slug: string;
+  metaTitle: string;       // ≤60 chars
+  metaDescription: string; // ≤160 chars
+  excerpt: string;
+  tags: string[];
+  contentMd: string;       // Markdown body
+  coverImageUrl: string | null;
+  publishedAt: string;     // ISO 8601
+}
+```
+
+---
+
+## Recipes
+
+### Listing page
+
+```tsx
+// app/blog/page.tsx
+import Link from "next/link";
+import { getPosts } from "@/lib/seoblog";
+
+export default async function BlogPage() {
+  const posts = await getPosts();
+  return (
+    <ul>
+      {posts.map((p) => (
+        <li key={p.id}>
+          <Link href={`/blog/${p.slug}`}>{p.title}</Link>
+        </li>
+      ))}
+    </ul>
+  );
+}
+```
+
+### Post page with metadata + JSON-LD
+
+```tsx
+// app/blog/[slug]/page.tsx
+import { notFound } from "next/navigation";
+import { marked } from "marked";
+import { getPost, getPosts } from "@/lib/seoblog";
+
+export async function generateStaticParams() {
+  const posts = await getPosts();
+  return posts.map((p) => ({ slug: p.slug }));
+}
+
+export async function generateMetadata({ params }) {
+  const { slug } = await params;
+  const post = await getPost(slug);
+  if (!post) return {};
+  return {
+    title: post.metaTitle,
+    description: post.metaDescription,
+  };
+}
+
+export default async function Page({ params }) {
+  const { slug } = await params;
+  const post = await getPost(slug);
+  if (!post) notFound();
+  return <article dangerouslySetInnerHTML={{ __html: marked.parse(post.contentMd) }} />;
+}
+```
+
+### Cache control
+
+```ts
+// Cache for one hour (default)
+await getPosts({ apiKey, revalidate: 3600 });
+
+// Always fresh (skip cache)
+await getPosts({ apiKey, revalidate: 0 });
+
+// Cache for a day
+await getPosts({ apiKey, revalidate: 86400 });
+```
+
+The SDK uses Next's built-in `fetch` cache, so revalidation works the same as any `fetch()` call in a Server Component.
+
+### Local development against a self-hosted dashboard
+
+```ts
+await getPosts({
+  apiKey: process.env.SEOBLOG_API_KEY!,
+  apiUrl: "http://localhost:3000",
+});
+```
+
+---
+
+## Environment variables
+
+| Variable               | Required | Description                                            |
+| ---------------------- | -------- | ------------------------------------------------------ |
+| `SEOBLOG_API_KEY`      | ✅       | Your site API key from the dashboard.                  |
+| `NEXT_PUBLIC_SITE_URL` | optional | Used by the scaffolded sitemap and RSS feed.           |
+
+Never expose `SEOBLOG_API_KEY` to the client — keep it server-side only (no `NEXT_PUBLIC_` prefix).
+
+---
+
+## CLI commands
+
+```
+npx @seoblog/next setup     Scaffold a Next.js blog
+npx @seoblog/next help      Show usage
+```
+
+The `setup` command is idempotent in spirit — it will refuse to overwrite existing files. If a conflict is found, it lists the offending paths and exits non-zero so you can resolve before retrying.
+
+---
+
+## Troubleshooting
+
+**"Unauthorized" / 401 from `getPosts`**
+The API key is missing, malformed, or revoked. Confirm `SEOBLOG_API_KEY` is set on the server (Vercel project env vars, not just `.env.local` in production) and that the key still exists in the dashboard.
+
+**Posts don't show up after publishing**
+Next's ISR cache is held until `revalidate` expires. Either drop `revalidate` lower, or trigger an on-demand revalidation from the dashboard's webhook (coming soon — `revalidatePath('/blog')`).
+
+**`marked` not found**
+The setup CLI prints it in the install step. If you skipped that, run `npm install marked`.
+
+**Pages Router**
+Not currently scaffolded. You can still call `getPosts` / `getPost` from `getStaticProps` / `getStaticPaths` — only the file structure differs.
+
+---
+
+## Links
+
+- Website: <https://www.nextseoblog.com>
+- Dashboard: <https://www.nextseoblog.com/dashboard>
+- Issues: <https://github.com/antonyefanov/nextseoblog/issues>
+
+## License
+
+MIT

package/dist/cli/detect.d.ts

@@ -0,0 +1,14 @@
+export interface ProjectInfo {
+    cwd: string;
+    isNextProject: boolean;
+    nextVersion: string | null;
+    router: "app" | "pages" | "unknown";
+    appDir: string | null;
+    hasSrcDir: boolean;
+    isTypescript: boolean;
+    hasTailwind: boolean;
+    hasTailwindTypography: boolean;
+    existingBlog: string | null;
+    packageManager: "npm" | "pnpm" | "yarn" | "bun";
+}
+export declare function detectProject(cwd: string): ProjectInfo;

package/dist/cli/detect.js

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function detectPackageManager(cwd) {
+    if (existsSync(join(cwd, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(join(cwd, "yarn.lock")))
+        return "yarn";
+    if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock")))
+        return "bun";
+    return "npm";
+}
+export function detectProject(cwd) {
+    const pkg = readJson(join(cwd, "package.json"));
+    const deps = {
+        ...(pkg?.dependencies ?? {}),
+        ...(pkg?.devDependencies ?? {}),
+    };
+    const nextVersion = deps["next"] ?? null;
+    const isNextProject = Boolean(nextVersion);
+    const hasSrcDir = existsSync(join(cwd, "src"));
+    const root = hasSrcDir ? join(cwd, "src") : cwd;
+    const appDirCandidate = join(root, "app");
+    const pagesDirCandidate = join(root, "pages");
+    const hasApp = existsSync(appDirCandidate);
+    const hasPages = existsSync(pagesDirCandidate);
+    const router = hasApp ? "app" : hasPages ? "pages" : "unknown";
+    const isTypescript = existsSync(join(cwd, "tsconfig.json")) || Boolean(deps["typescript"]);
+    const hasTailwind = Boolean(deps["tailwindcss"]);
+    const hasTailwindTypography = Boolean(deps["@tailwindcss/typography"]);
+    const blogCandidates = [
+        join(root, "app", "blog"),
+        join(root, "app", "posts"),
+        join(root, "pages", "blog"),
+        join(root, "pages", "posts"),
+        join(cwd, "content", "blog"),
+        join(cwd, "content", "posts"),
+        join(cwd, "posts"),
+    ];
+    const existingBlog = blogCandidates.find((p) => existsSync(p)) ?? null;
+    return {
+        cwd,
+        isNextProject,
+        nextVersion,
+        router,
+        appDir: hasApp ? appDirCandidate : null,
+        hasSrcDir,
+        isTypescript,
+        hasTailwind,
+        hasTailwindTypography,
+        existingBlog,
+        packageManager: detectPackageManager(cwd),
+    };
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { runSetup } from "./setup.js";
+const HELP = `@seoblog/next — CLI
+
+Usage:
+  npx @seoblog/next setup     Scaffold a Next.js blog wired to your SEO Blog dashboard
+  npx @seoblog/next help      Show this message
+
+Docs: https://www.nextseoblog.com/docs
+`;
+async function main() {
+    const [, , cmd = "setup"] = process.argv;
+    switch (cmd) {
+        case "setup":
+            return runSetup();
+        case "help":
+        case "--help":
+        case "-h":
+            process.stdout.write(HELP);
+            return 0;
+        default:
+            process.stderr.write(`Unknown command: ${cmd}\n\n${HELP}`);
+            return 1;
+    }
+}
+main().then((code) => process.exit(code), (err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/cli/prompt.d.ts

@@ -0,0 +1,7 @@
+export declare function ask(question: string, defaultValue?: string): Promise<string>;
+export declare function confirm(question: string, defaultYes?: boolean): Promise<boolean>;
+export declare function select<T extends string>(question: string, options: {
+    value: T;
+    label: string;
+}[], defaultIndex?: number): Promise<T>;
+export declare function closePrompt(): void;

package/dist/cli/prompt.js

@@ -0,0 +1,74 @@
+import { createInterface } from "node:readline";
+import { stdin, stdout } from "node:process";
+let rl = null;
+let lineQueue = [];
+let waiters = [];
+let closed = false;
+function ensureReader() {
+    if (rl)
+        return;
+    rl = createInterface({ input: stdin, terminal: false });
+    rl.on("line", (line) => {
+        if (waiters.length > 0) {
+            const resolve = waiters.shift();
+            resolve(line);
+        }
+        else {
+            lineQueue.push(line);
+        }
+    });
+    rl.on("close", () => {
+        closed = true;
+        while (waiters.length > 0) {
+            const resolve = waiters.shift();
+            resolve(null);
+        }
+    });
+}
+function readLine() {
+    ensureReader();
+    if (lineQueue.length > 0)
+        return Promise.resolve(lineQueue.shift());
+    if (closed)
+        return Promise.resolve(null);
+    return new Promise((resolve) => waiters.push(resolve));
+}
+export async function ask(question, defaultValue) {
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    stdout.write(`${question}${suffix} `);
+    const line = await readLine();
+    const answer = (line ?? "").trim();
+    return answer || defaultValue || "";
+}
+export async function confirm(question, defaultYes = true) {
+    const hint = defaultYes ? "Y/n" : "y/N";
+    stdout.write(`${question} [${hint}] `);
+    const line = await readLine();
+    const answer = (line ?? "").trim().toLowerCase();
+    if (!answer)
+        return defaultYes;
+    return answer === "y" || answer === "yes";
+}
+export async function select(question, options, defaultIndex = 0) {
+    console.log(question);
+    options.forEach((opt, i) => {
+        const marker = i === defaultIndex ? "›" : " ";
+        console.log(`  ${marker} ${i + 1}. ${opt.label}`);
+    });
+    stdout.write(`Pick (1-${options.length}, default ${defaultIndex + 1}): `);
+    const line = await readLine();
+    const answer = (line ?? "").trim();
+    if (!answer)
+        return options[defaultIndex].value;
+    const idx = parseInt(answer, 10) - 1;
+    if (Number.isNaN(idx) || idx < 0 || idx >= options.length) {
+        return options[defaultIndex].value;
+    }
+    return options[idx].value;
+}
+export function closePrompt() {
+    if (rl) {
+        rl.close();
+        rl = null;
+    }
+}

package/dist/cli/scaffold.d.ts

@@ -0,0 +1,14 @@
+export interface ScaffoldFile {
+    path: string;
+    content: string;
+    /** If true and file exists, skip. If false and file exists, error. */
+    skipIfExists?: boolean;
+}
+export interface WriteResult {
+    written: string[];
+    skipped: string[];
+    conflicts: string[];
+}
+export declare function writeFiles(cwd: string, files: ScaffoldFile[]): WriteResult;
+export declare function appendEnvLocal(cwd: string, entries: Record<string, string>): "created" | "updated" | "noop";
+export declare function relPath(cwd: string, path: string): string;

package/dist/cli/scaffold.js

@@ -0,0 +1,48 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+export function writeFiles(cwd, files) {
+    const written = [];
+    const skipped = [];
+    const conflicts = [];
+    for (const file of files) {
+        const abs = join(cwd, file.path);
+        if (existsSync(abs)) {
+            if (file.skipIfExists) {
+                skipped.push(file.path);
+            }
+            else {
+                conflicts.push(file.path);
+            }
+            continue;
+        }
+        mkdirSync(dirname(abs), { recursive: true });
+        writeFileSync(abs, file.content, "utf8");
+        written.push(file.path);
+    }
+    return { written, skipped, conflicts };
+}
+export function appendEnvLocal(cwd, entries) {
+    const envPath = join(cwd, ".env.local");
+    let existing = "";
+    let existed = false;
+    if (existsSync(envPath)) {
+        existed = true;
+        existing = readFileSync(envPath, "utf8");
+    }
+    const toAdd = [];
+    for (const [key, value] of Object.entries(entries)) {
+        const pattern = new RegExp(`^${key}=`, "m");
+        if (!pattern.test(existing)) {
+            toAdd.push(`${key}=${value}`);
+        }
+    }
+    if (toAdd.length === 0)
+        return "noop";
+    const prefix = existed && !existing.endsWith("\n") ? "\n" : "";
+    const block = `${prefix}# Added by @seoblog/next setup\n${toAdd.join("\n")}\n`;
+    writeFileSync(envPath, existing + block, "utf8");
+    return existed ? "updated" : "created";
+}
+export function relPath(cwd, path) {
+    return relative(cwd, path) || ".";
+}

package/dist/cli/setup.d.ts

@@ -0,0 +1 @@
+export declare function runSetup(): Promise<number>;

package/dist/cli/setup.js

@@ -0,0 +1,127 @@
+import { join } from "node:path";
+import { detectProject } from "./detect.js";
+import { ask, confirm, closePrompt } from "./prompt.js";
+import { appendEnvLocal, writeFiles, } from "./scaffold.js";
+import { blogIndexPage, blogPostPage, envExample, feedRouteTs, libSeoblogTs, sitemapTs, } from "./templates.js";
+const DASHBOARD_URL = "https://www.nextseoblog.com/dashboard";
+function color(code, s) {
+    return `\x1b[${code}m${s}\x1b[0m`;
+}
+const bold = (s) => color(1, s);
+const green = (s) => color(32, s);
+const yellow = (s) => color(33, s);
+const red = (s) => color(31, s);
+const dim = (s) => color(2, s);
+export async function runSetup() {
+    const cwd = process.cwd();
+    console.log(bold("\n@seoblog/next setup\n"));
+    const info = detectProject(cwd);
+    if (!info.isNextProject) {
+        console.log(red("✗ This doesn't look like a Next.js project."), "\n  No `next` dependency found in package.json.", `\n  Run this command from the root of your Next.js app.\n`);
+        closePrompt();
+        return 1;
+    }
+    if (info.router === "pages") {
+        console.log(yellow("! Detected the Pages Router."), "\n  This CLI currently only scaffolds for the App Router.", "\n  Migrate to /app or import @seoblog/next manually in your pages.\n");
+        closePrompt();
+        return 1;
+    }
+    console.log(`${green("✓")} Next.js ${info.nextVersion ?? "?"} · ${info.router === "app" ? "App Router" : "unknown router"} · ${info.isTypescript ? "TypeScript" : "JavaScript"}${info.hasSrcDir ? " · src/" : ""}${info.hasTailwind ? " · Tailwind" : ""}`);
+    if (info.existingBlog) {
+        console.log(yellow(`! Existing blog detected at ${info.existingBlog}`), "\n  This CLI will not touch it. Pick a different path below or cancel.\n");
+    }
+    const blogBasePath = await ask("Where should the blog live?", info.existingBlog ? "/blog-ai" : "/blog");
+    const normalizedBase = blogBasePath.startsWith("/")
+        ? blogBasePath
+        : `/${blogBasePath}`;
+    const siteName = await ask("Site name (for RSS + metadata):", "My Site");
+    const siteUrl = await ask("Production site URL (used in sitemap + RSS):", "https://example.com");
+    const wantSitemap = await confirm("Generate app/sitemap.ts?", true);
+    const wantFeed = await confirm("Generate RSS feed at /blog/feed.xml?", true);
+    console.log();
+    closePrompt();
+    const rootSegment = info.hasSrcDir ? "src" : "";
+    const appBase = join(rootSegment, "app");
+    const libBase = join(rootSegment, "lib");
+    const blogRoute = join(appBase, normalizedBase.replace(/^\//, ""));
+    const ctx = {
+        blogBasePath: normalizedBase,
+        siteName,
+        siteUrl,
+    };
+    const files = [
+        {
+            path: join(libBase, "seoblog.ts"),
+            content: libSeoblogTs(),
+        },
+        {
+            path: join(blogRoute, "page.tsx"),
+            content: blogIndexPage(ctx),
+        },
+        {
+            path: join(blogRoute, "[slug]", "page.tsx"),
+            content: blogPostPage(ctx),
+        },
+    ];
+    if (wantFeed) {
+        files.push({
+            path: join(blogRoute, "feed.xml", "route.ts"),
+            content: feedRouteTs(ctx),
+        });
+    }
+    if (wantSitemap) {
+        files.push({
+            path: join(appBase, "sitemap.ts"),
+            content: sitemapTs(ctx),
+            skipIfExists: true,
+        });
+    }
+    files.push({
+        path: ".env.example",
+        content: envExample(),
+        skipIfExists: true,
+    });
+    const result = writeFiles(cwd, files);
+    if (result.conflicts.length > 0) {
+        console.log(red("✗ Refusing to overwrite existing files:"));
+        for (const c of result.conflicts)
+            console.log(`  ${c}`);
+        console.log("\n  Move or delete them and re-run, or pass a different blog path.\n");
+        return 1;
+    }
+    for (const f of result.written)
+        console.log(`${green("+")} ${f}`);
+    for (const f of result.skipped)
+        console.log(`${dim("·")} ${f} ${dim("(exists, skipped)")}`);
+    const envResult = appendEnvLocal(cwd, {
+        SEOBLOG_API_KEY: "",
+        NEXT_PUBLIC_SITE_URL: siteUrl,
+    });
+    if (envResult === "created")
+        console.log(`${green("+")} .env.local`);
+    if (envResult === "updated")
+        console.log(`${green("~")} .env.local ${dim("(appended)")}`);
+    const pmInstall = info.packageManager === "pnpm"
+        ? "pnpm add"
+        : info.packageManager === "yarn"
+            ? "yarn add"
+            : info.packageManager === "bun"
+                ? "bun add"
+                : "npm install";
+    const missing = [];
+    if (!info.hasTailwindTypography && info.hasTailwind) {
+        missing.push("@tailwindcss/typography");
+    }
+    missing.push("marked");
+    console.log(`\n${bold("Next steps:")}`);
+    console.log(`  1. Install runtime deps:`);
+    console.log(`       ${pmInstall} @seoblog/next ${missing.join(" ")}`);
+    console.log(`  2. Grab your API key from ${DASHBOARD_URL}`);
+    console.log(`     and paste it into ${bold("SEOBLOG_API_KEY")} in .env.local`);
+    if (info.hasTailwind && !info.hasTailwindTypography) {
+        console.log(`  3. Add ${bold("@tailwindcss/typography")} to your tailwind config plugins`);
+    }
+    console.log(`  ${info.hasTailwind && !info.hasTailwindTypography ? "4" : "3"}. Start your dev server and visit ${bold(normalizedBase)}`);
+    console.log();
+    return 0;
+}

package/dist/cli/templates.d.ts

@@ -0,0 +1,11 @@
+export interface TemplateContext {
+    blogBasePath: string;
+    siteName: string;
+    siteUrl: string;
+}
+export declare function libSeoblogTs(): string;
+export declare function blogIndexPage(ctx: TemplateContext): string;
+export declare function blogPostPage(ctx: TemplateContext): string;
+export declare function feedRouteTs(ctx: TemplateContext): string;
+export declare function sitemapTs(ctx: TemplateContext): string;
+export declare function envExample(): string;

package/dist/cli/templates.js

@@ -0,0 +1,217 @@
+export function libSeoblogTs() {
+    return `import { getPosts as sdkGetPosts, getPost as sdkGetPost } from "@seoblog/next";
+
+const apiKey = process.env.SEOBLOG_API_KEY;
+
+if (!apiKey) {
+  throw new Error(
+    "SEOBLOG_API_KEY is not set. Add it to .env.local — grab the key from https://www.nextseoblog.com/dashboard",
+  );
+}
+
+export function getPosts() {
+  return sdkGetPosts({ apiKey: apiKey! });
+}
+
+export function getPost(slug: string) {
+  return sdkGetPost(slug, { apiKey: apiKey! });
+}
+`;
+}
+export function blogIndexPage(ctx) {
+    return `import Link from "next/link";
+import type { Metadata } from "next";
+
+import { getPosts } from "@/lib/seoblog";
+
+export const metadata: Metadata = {
+  title: "Blog | ${ctx.siteName}",
+  description: "Latest articles and updates.",
+};
+
+export default async function BlogPage() {
+  const posts = await getPosts();
+
+  return (
+    <main className="mx-auto max-w-3xl px-4 py-12">
+      <h1 className="mb-8 text-4xl font-bold tracking-tight">Blog</h1>
+      <ul className="space-y-8">
+        {posts.map((post) => (
+          <li key={post.id} className="border-b pb-6 last:border-b-0">
+            <Link href={\`${ctx.blogBasePath}/\${post.slug}\`} className="group">
+              <h2 className="text-2xl font-semibold group-hover:underline">
+                {post.title}
+              </h2>
+              {post.excerpt ? (
+                <p className="mt-2 text-muted-foreground">{post.excerpt}</p>
+              ) : null}
+              <p className="mt-2 text-sm text-muted-foreground">
+                {post.publishedAt
+                  ? new Date(post.publishedAt).toLocaleDateString()
+                  : null}
+              </p>
+            </Link>
+          </li>
+        ))}
+        {posts.length === 0 ? (
+          <li className="text-muted-foreground">No posts yet — check back soon.</li>
+        ) : null}
+      </ul>
+    </main>
+  );
+}
+`;
+}
+export function blogPostPage(ctx) {
+    return `import { notFound } from "next/navigation";
+import { marked } from "marked";
+import type { Metadata } from "next";
+
+import { getPost, getPosts } from "@/lib/seoblog";
+
+interface Props {
+  params: Promise<{ slug: string }>;
+}
+
+export async function generateStaticParams() {
+  const posts = await getPosts();
+  return posts.map((p) => ({ slug: p.slug }));
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { slug } = await params;
+  const post = await getPost(slug);
+  if (!post) return {};
+
+  return {
+    title: post.metaTitle || post.title,
+    description: post.metaDescription,
+    openGraph: {
+      title: post.metaTitle || post.title,
+      description: post.metaDescription,
+      type: "article",
+      images: post.coverImageUrl ? [post.coverImageUrl] : undefined,
+      publishedTime: post.publishedAt,
+    },
+  };
+}
+
+export default async function PostPage({ params }: Props) {
+  const { slug } = await params;
+  const post = await getPost(slug);
+  if (!post) notFound();
+
+  const html = marked.parse(post.contentMd) as string;
+
+  const jsonLd = {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: post.title,
+    description: post.metaDescription,
+    image: post.coverImageUrl ?? undefined,
+    datePublished: post.publishedAt,
+    keywords: post.tags.join(", "),
+  };
+
+  return (
+    <main className="mx-auto max-w-3xl px-4 py-12">
+      <script
+        type="application/ld+json"
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
+      />
+      <article className="prose prose-neutral dark:prose-invert max-w-none">
+        <h1>{post.title}</h1>
+        {post.publishedAt ? (
+          <p className="text-sm text-muted-foreground">
+            {new Date(post.publishedAt).toLocaleDateString()}
+          </p>
+        ) : null}
+        {/* eslint-disable-next-line react/no-danger */}
+        <div dangerouslySetInnerHTML={{ __html: html }} />
+      </article>
+    </main>
+  );
+}
+`;
+}
+export function feedRouteTs(ctx) {
+    return `import { getPosts } from "@/lib/seoblog";
+
+const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL ?? "${ctx.siteUrl}";
+const SITE_NAME = "${ctx.siteName}";
+
+function escapeXml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+export async function GET() {
+  const posts = await getPosts();
+
+  const items = posts
+    .map(
+      (p) => \`
+    <item>
+      <title>\${escapeXml(p.title)}</title>
+      <link>\${SITE_URL}${ctx.blogBasePath}/\${p.slug}</link>
+      <guid isPermaLink="true">\${SITE_URL}${ctx.blogBasePath}/\${p.slug}</guid>
+      <description>\${escapeXml(p.metaDescription || p.excerpt)}</description>
+      <pubDate>\${p.publishedAt ? new Date(p.publishedAt).toUTCString() : ""}</pubDate>
+    </item>\`,
+    )
+    .join("");
+
+  const xml = \`<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>\${escapeXml(SITE_NAME)}</title>
+    <link>\${SITE_URL}</link>
+    <description>Latest posts from \${escapeXml(SITE_NAME)}</description>
+    \${items}
+  </channel>
+</rss>\`;
+
+  return new Response(xml, {
+    headers: { "Content-Type": "application/rss+xml; charset=utf-8" },
+  });
+}
+`;
+}
+export function sitemapTs(ctx) {
+    return `import type { MetadataRoute } from "next";
+
+import { getPosts } from "@/lib/seoblog";
+
+const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL ?? "${ctx.siteUrl}";
+
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  const posts = await getPosts();
+
+  return [
+    {
+      url: \`\${SITE_URL}${ctx.blogBasePath}\`,
+      changeFrequency: "daily",
+      priority: 0.8,
+    },
+    ...posts.map((post) => ({
+      url: \`\${SITE_URL}${ctx.blogBasePath}/\${post.slug}\`,
+      lastModified: post.publishedAt ? new Date(post.publishedAt) : undefined,
+      changeFrequency: "weekly" as const,
+      priority: 0.6,
+    })),
+  ];
+}
+`;
+}
+export function envExample() {
+    return `# Get your API key from https://www.nextseoblog.com/dashboard
+SEOBLOG_API_KEY=
+
+# Used by sitemap.ts and feed.xml — set to your production URL
+NEXT_PUBLIC_SITE_URL=http://localhost:3000
+`;
+}

package/dist/index.js

@@ -1,4 +1,4 @@
-const DEFAULT_API_URL = "https://nextseoblog.com";
+const DEFAULT_API_URL = "https://www.nextseoblog.com";
 function buildHeaders(apiKey) {
     return { Authorization: `Bearer ${apiKey}` };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seoblog/next",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Fetch AI-generated blog posts from your SEO Blog dashboard into your Next.js site.",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,13 +12,26 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "bin": {
+    "seoblog": "./dist/cli/index.js"
+  },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && chmod +x dist/cli/index.js",
     "dev": "tsc --watch"
   },
+  "keywords": [
+    "nextjs",
+    "blog",
+    "seo",
+    "cms",
+    "ai",
+    "content"
+  ],
+  "license": "MIT",
   "devDependencies": {
     "typescript": "^5.9.3"
   },