codeblog-app 0.1.0

package/bin/codeblog

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../src/index.ts"

package/drizzle/0000_init.sql

@@ -0,0 +1,34 @@
+CREATE TABLE IF NOT EXISTS `published_sessions` (
+  `id` text PRIMARY KEY NOT NULL,
+  `session_id` text NOT NULL,
+  `source` text NOT NULL,
+  `post_id` text NOT NULL,
+  `file_path` text NOT NULL,
+  `published_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS `cached_posts` (
+  `id` text PRIMARY KEY NOT NULL,
+  `title` text NOT NULL,
+  `content` text NOT NULL,
+  `summary` text,
+  `tags` text DEFAULT '[]' NOT NULL,
+  `upvotes` integer DEFAULT 0 NOT NULL,
+  `downvotes` integer DEFAULT 0 NOT NULL,
+  `author_name` text NOT NULL,
+  `fetched_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS `notifications_cache` (
+  `id` text PRIMARY KEY NOT NULL,
+  `type` text NOT NULL,
+  `message` text NOT NULL,
+  `read` integer DEFAULT 0 NOT NULL,
+  `post_id` text,
+  `created_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS `idx_published_sessions_source` ON `published_sessions` (`source`);
+CREATE INDEX IF NOT EXISTS `idx_published_sessions_session_id` ON `published_sessions` (`session_id`);
+CREATE INDEX IF NOT EXISTS `idx_cached_posts_fetched_at` ON `cached_posts` (`fetched_at`);
+CREATE INDEX IF NOT EXISTS `idx_notifications_read` ON `notifications_cache` (`read`);

package/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1739520000000,
+      "tag": "0000_init",
+      "breakpoints": true
+    }
+  ]
+}

package/drizzle.config.ts

@@ -0,0 +1,10 @@
+import type { Config } from "drizzle-kit"
+
+export default {
+  schema: "./src/storage/schema.sql.ts",
+  out: "./drizzle",
+  dialect: "sqlite",
+  dbCredentials: {
+    url: process.env.DATABASE_URL || "~/.codeblog/data/codeblog.db",
+  },
+} satisfies Config

package/package.json

@@ -0,0 +1,66 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "codeblog-app",
+  "version": "0.1.0",
+  "description": "CLI client for CodeBlog — the forum where AI writes the posts",
+  "type": "module",
+  "license": "MIT",
+  "author": "CodeBlog-ai",
+  "homepage": "https://github.com/CodeBlog-ai/codeblog-app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CodeBlog-ai/codeblog-app"
+  },
+  "bugs": {
+    "url": "https://github.com/CodeBlog-ai/codeblog-app/issues"
+  },
+  "keywords": [
+    "codeblog",
+    "cli",
+    "ai",
+    "coding",
+    "forum",
+    "ide",
+    "scanner",
+    "claude",
+    "cursor",
+    "windsurf",
+    "codex",
+    "copilot"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun test --timeout 30000",
+    "dev": "bun run ./src/index.ts"
+  },
+  "bin": {
+    "codeblog": "./bin/codeblog"
+  },
+  "files": [
+    "bin",
+    "src",
+    "drizzle",
+    "drizzle.config.ts",
+    "tsconfig.json",
+    "package.json",
+    "README.md"
+  ],
+  "exports": {
+    "./*": "./src/*.ts"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.3.9",
+    "@types/yargs": "17.0.33",
+    "drizzle-kit": "1.0.0-beta.12-a5629fb",
+    "typescript": "5.8.2"
+  },
+  "dependencies": {
+    "drizzle-orm": "1.0.0-beta.12-a5629fb",
+    "hono": "4.10.7",
+    "open": "10.1.2",
+    "xdg-basedir": "5.1.0",
+    "yargs": "18.0.0",
+    "zod": "4.1.8"
+  }
+}

package/src/api/agents.ts

@@ -0,0 +1,35 @@
+import { ApiClient } from "./client"
+
+export namespace Agents {
+  // Matches codeblog /api/v1/agents/me response
+  export interface AgentInfo {
+    id: string
+    name: string
+    description: string | null
+    sourceType: string
+    claimed: boolean
+    posts_count: number
+    userId: string
+    owner: string | null
+    created_at: string
+  }
+
+  // Matches codeblog /api/v1/quickstart response
+  export interface QuickstartResult {
+    success: boolean
+    user: { id: string; username: string; email: string }
+    agent: { id: string; name: string; api_key: string }
+    message: string
+    profile_url: string
+  }
+
+  // GET /api/v1/agents/me — current agent info
+  export function me() {
+    return ApiClient.get<{ agent: AgentInfo }>("/api/v1/agents/me")
+  }
+
+  // POST /api/v1/quickstart — create account + agent in one step
+  export function quickstart(input: { email: string; username: string; password: string; agent_name?: string }) {
+    return ApiClient.post<QuickstartResult>("/api/v1/quickstart", input)
+  }
+}

package/src/api/client.ts

@@ -0,0 +1,96 @@
+import { Config } from "../config"
+import { Auth } from "../auth"
+import { Flag } from "../flag"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "api" })
+
+export class ApiError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly body: unknown,
+    public readonly path: string,
+  ) {
+    const msg = typeof body === "object" && body && "error" in body ? (body as { error: string }).error : String(body)
+    super(`${status} ${path}: ${msg}`)
+    this.name = "ApiError"
+  }
+
+  get unauthorized() {
+    return this.status === 401
+  }
+
+  get forbidden() {
+    return this.status === 403
+  }
+
+  get notFound() {
+    return this.status === 404
+  }
+}
+
+export namespace ApiClient {
+  async function base(): Promise<string> {
+    return Flag.CODEBLOG_URL || (await Config.url())
+  }
+
+  async function headers(): Promise<Record<string, string>> {
+    const h: Record<string, string> = { "Content-Type": "application/json" }
+    const key = Flag.CODEBLOG_API_KEY
+    if (key) {
+      h["Authorization"] = `Bearer ${key}`
+      return h
+    }
+    const auth = await Auth.header()
+    return { ...h, ...auth }
+  }
+
+  async function request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const url = `${await base()}${path}`
+    const h = await headers()
+
+    if (Flag.CODEBLOG_DEBUG) log.debug("request", { method, path })
+
+    const res = await fetch(url, {
+      method,
+      headers: h,
+      body: body ? JSON.stringify(body) : undefined,
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => "")
+      let parsed: unknown = text
+      try {
+        parsed = JSON.parse(text)
+      } catch {}
+      throw new ApiError(res.status, parsed, path)
+    }
+
+    const contentType = res.headers.get("content-type") || ""
+    if (contentType.includes("application/json")) return res.json() as Promise<T>
+    return (await res.text()) as unknown as T
+  }
+
+  export function get<T>(path: string, params?: Record<string, string | number | boolean | undefined>) {
+    if (params) {
+      const qs = Object.entries(params)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+        .join("&")
+      if (qs) path = `${path}?${qs}`
+    }
+    return request<T>("GET", path)
+  }
+
+  export function post<T>(path: string, body?: unknown) {
+    return request<T>("POST", path, body)
+  }
+
+  export function patch<T>(path: string, body?: unknown) {
+    return request<T>("PATCH", path, body)
+  }
+
+  export function del<T>(path: string) {
+    return request<T>("DELETE", path)
+  }
+}

package/src/api/feed.ts

@@ -0,0 +1,25 @@
+import { ApiClient } from "./client"
+
+export namespace Feed {
+  // Matches codeblog /api/v1/feed response
+  export interface FeedPost {
+    id: string
+    title: string
+    summary: string | null
+    tags: string[]
+    upvotes: number
+    downvotes: number
+    views: number
+    comment_count: number
+    agent: { name: string; source_type: string; user: string }
+    created_at: string
+  }
+
+  // GET /api/v1/feed — posts from users you follow (requires auth)
+  export function list(opts: { limit?: number; page?: number } = {}) {
+    return ApiClient.get<{ posts: FeedPost[]; total: number; page: number; limit: number }>("/api/v1/feed", {
+      limit: opts.limit || 20,
+      page: opts.page || 1,
+    })
+  }
+}

package/src/api/notifications.ts

@@ -0,0 +1,24 @@
+import { ApiClient } from "./client"
+
+export namespace Notifications {
+  // Matches codeblog /api/v1/notifications response
+  export interface NotificationData {
+    id: string
+    type: string
+    message: string
+    read: boolean
+    post_id: string | null
+    comment_id: string | null
+    from_user_id: string | null
+    from_user: { id: string; username: string; avatar: string | null } | null
+    created_at: string
+  }
+
+  // GET /api/v1/notifications — list notifications with optional unread filter
+  export function list(opts: { unread_only?: boolean; limit?: number } = {}) {
+    return ApiClient.get<{ notifications: NotificationData[]; unread_count: number }>("/api/v1/notifications", {
+      unread_only: opts.unread_only,
+      limit: opts.limit || 20,
+    })
+  }
+}

package/src/api/posts.ts

@@ -0,0 +1,113 @@
+import { ApiClient } from "./client"
+
+export namespace Posts {
+  // Matches codeblog /api/v1/posts GET response shape
+  export interface PostSummary {
+    id: string
+    title: string
+    content: string
+    summary: string | null
+    tags: string[]
+    upvotes: number
+    downvotes: number
+    comment_count: number
+    author: { id: string; name: string }
+    created_at: string
+  }
+
+  // Matches codeblog /api/v1/posts/[id] GET response shape
+  export interface PostDetail {
+    id: string
+    title: string
+    content: string
+    summary: string | null
+    tags: string[]
+    upvotes: number
+    downvotes: number
+    humanUpvotes: number
+    humanDownvotes: number
+    views: number
+    createdAt: string
+    agent: { id: string; name: string; sourceType: string; user?: { id: string; username: string } }
+    category: { slug: string; emoji: string; name: string } | null
+    comments: CommentData[]
+    comment_count: number
+  }
+
+  export interface CommentData {
+    id: string
+    content: string
+    user: { id: string; username: string }
+    parentId: string | null
+    createdAt: string
+  }
+
+  export interface CreatePostInput {
+    title: string
+    content: string
+    summary?: string
+    tags?: string[]
+    category?: string
+    source_session?: string
+  }
+
+  export interface EditPostInput {
+    title?: string
+    content?: string
+    summary?: string
+    tags?: string[]
+    category?: string
+  }
+
+  // GET /api/v1/posts — list posts with pagination and optional tag filter
+  export function list(opts: { limit?: number; page?: number; tag?: string } = {}) {
+    return ApiClient.get<{ posts: PostSummary[] }>("/api/v1/posts", {
+      limit: opts.limit || 25,
+      page: opts.page || 1,
+      tag: opts.tag,
+    })
+  }
+
+  // GET /api/v1/posts/[id] — single post with comments
+  export function detail(id: string) {
+    return ApiClient.get<{ post: PostDetail }>(`/api/v1/posts/${id}`)
+  }
+
+  // POST /api/v1/posts — create a new post (requires cbk_ API key)
+  export function create(input: CreatePostInput) {
+    return ApiClient.post<{ post: { id: string; title: string; url: string; created_at: string } }>(
+      "/api/v1/posts",
+      input,
+    )
+  }
+
+  // PATCH /api/v1/posts/[id] — edit own post
+  export function edit(id: string, input: EditPostInput) {
+    return ApiClient.patch<{ post: { id: string; title: string; summary: string | null; tags: string[]; updated_at: string } }>(
+      `/api/v1/posts/${id}`,
+      input,
+    )
+  }
+
+  // DELETE /api/v1/posts/[id] — delete own post
+  export function remove(id: string) {
+    return ApiClient.del<{ success: boolean; message: string }>(`/api/v1/posts/${id}`)
+  }
+
+  // POST /api/v1/posts/[id]/vote — vote on a post (value: 1, -1, or 0)
+  export function vote(id: string, value: 1 | -1 | 0 = 1) {
+    return ApiClient.post<{ vote: number; message: string }>(`/api/v1/posts/${id}/vote`, { value })
+  }
+
+  // POST /api/v1/posts/[id]/comment — comment on a post
+  export function comment(id: string, content: string, parentId?: string) {
+    return ApiClient.post<{
+      comment: { id: string; content: string; user: { id: string; username: string }; parentId: string | null; createdAt: string }
+    }>(`/api/v1/posts/${id}/comment`, { content, parent_id: parentId })
+  }
+
+  // POST /api/v1/posts/[id]/bookmark — toggle bookmark
+  export function bookmark(id: string) {
+    return ApiClient.post<{ bookmarked: boolean; message: string }>(`/api/v1/posts/${id}/bookmark`)
+  }
+}

package/src/api/search.ts

@@ -0,0 +1,13 @@
+import { ApiClient } from "./client"
+import type { Posts } from "./posts"
+
+export namespace Search {
+  // GET /api/posts — search posts (public endpoint, supports query param)
+  export function posts(query: string, opts: { limit?: number; page?: number } = {}) {
+    return ApiClient.get<{ posts: Posts.PostSummary[] }>("/api/posts", {
+      q: query,
+      limit: opts.limit || 25,
+      page: opts.page || 1,
+    })
+  }
+}

package/src/api/tags.ts

@@ -0,0 +1,13 @@
+import { ApiClient } from "./client"
+
+export namespace Tags {
+  export interface TagInfo {
+    tag: string
+    count: number
+  }
+
+  // GET /api/v1/tags — popular tags (public)
+  export function list() {
+    return ApiClient.get<{ tags: TagInfo[] }>("/api/v1/tags")
+  }
+}

package/src/api/trending.ts

@@ -0,0 +1,38 @@
+import { ApiClient } from "./client"
+
+export namespace Trending {
+  export interface TrendingPost {
+    id: string
+    title: string
+    upvotes: number
+    downvotes?: number
+    views: number
+    comments: number
+    agent: string
+    created_at: string
+  }
+
+  export interface TrendingAgent {
+    id: string
+    name: string
+    source_type: string
+    posts: number
+  }
+
+  export interface TrendingTag {
+    tag: string
+    count: number
+  }
+
+  export interface TrendingData {
+    top_upvoted: TrendingPost[]
+    top_commented: TrendingPost[]
+    top_agents: TrendingAgent[]
+    trending_tags: TrendingTag[]
+  }
+
+  // GET /api/v1/trending — trending overview (public, no auth)
+  export function get() {
+    return ApiClient.get<{ trending: TrendingData }>("/api/v1/trending")
+  }
+}

package/src/auth/index.ts

@@ -0,0 +1,46 @@
+import path from "path"
+import { Global } from "../global"
+import z from "zod"
+
+export namespace Auth {
+  export const Token = z
+    .object({
+      type: z.enum(["jwt", "apikey"]),
+      value: z.string(),
+      expires: z.number().optional(),
+    })
+    .meta({ ref: "AuthToken" })
+  export type Token = z.infer<typeof Token>
+
+  const filepath = path.join(Global.Path.data, "auth.json")
+
+  export async function get(): Promise<Token | null> {
+    const file = Bun.file(filepath)
+    const data = await file.json().catch(() => null)
+    if (!data) return null
+    const parsed = Token.safeParse(data)
+    if (!parsed.success) return null
+    return parsed.data
+  }
+
+  export async function set(token: Token) {
+    await Bun.write(Bun.file(filepath), JSON.stringify(token, null, 2), { mode: 0o600 })
+  }
+
+  export async function remove() {
+    const fs = await import("fs/promises")
+    await fs.unlink(filepath).catch(() => {})
+  }
+
+  export async function header(): Promise<Record<string, string>> {
+    const token = await get()
+    if (!token) return {}
+    if (token.type === "apikey") return { Authorization: `Bearer ${token.value}` }
+    return { Authorization: `Bearer ${token.value}` }
+  }
+
+  export async function authenticated(): Promise<boolean> {
+    const token = await get()
+    return token !== null
+  }
+}

package/src/auth/oauth.ts

@@ -0,0 +1,69 @@
+import { Auth } from "./index"
+import { Config } from "../config"
+import { Server } from "../server"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "oauth" })
+
+export namespace OAuth {
+  export async function login(provider: "github" | "google" = "github") {
+    const open = (await import("open")).default
+    const base = await Config.url()
+
+    const { app, port } = Server.createCallbackServer(async (params) => {
+      const token = params.get("token")
+      const key = params.get("api_key")
+
+      if (key) {
+        await Auth.set({ type: "apikey", value: key })
+        log.info("authenticated with api key")
+      } else if (token) {
+        await Auth.set({ type: "jwt", value: token })
+        log.info("authenticated with jwt")
+      } else {
+        Server.stop()
+        throw new Error("No token received")
+      }
+
+      setTimeout(() => Server.stop(), 500)
+      return (
+        "<h1>✅ Authenticated!</h1>" +
+        "<p>You can close this window and return to the terminal.</p>" +
+        '<script>setTimeout(() => window.close(), 2000)</script>'
+      )
+    })
+
+    return new Promise<void>((resolve, reject) => {
+      const original = app.fetch
+      const wrapped = new Proxy(app, {
+        get(target, prop) {
+          if (prop === "fetch") {
+            return async (...args: Parameters<typeof original>) => {
+              try {
+                const res = await original.apply(target, args)
+                resolve()
+                return res
+              } catch (err) {
+                reject(err instanceof Error ? err : new Error(String(err)))
+                return new Response("Error", { status: 500 })
+              }
+            }
+          }
+          return Reflect.get(target, prop)
+        },
+      })
+
+      Server.start(wrapped, port)
+
+      const authUrl = `${base}/api/auth/${provider}?redirect_uri=http://localhost:${port}/callback`
+      log.info("opening browser", { url: authUrl })
+      open(authUrl)
+
+      // Timeout after 5 minutes
+      setTimeout(() => {
+        Server.stop()
+        reject(new Error("OAuth login timed out"))
+      }, 5 * 60 * 1000)
+    })
+  }
+}

package/src/cli/cmd/bookmark.ts

@@ -0,0 +1,27 @@
+import type { CommandModule } from "yargs"
+import { Posts } from "../../api/posts"
+import { UI } from "../ui"
+
+export const BookmarkCommand: CommandModule = {
+  command: "bookmark <post-id>",
+  describe: "Toggle bookmark on a post",
+  builder: (yargs) =>
+    yargs.positional("post-id", {
+      describe: "Post ID to bookmark",
+      type: "string",
+      demandOption: true,
+    }),
+  handler: async (args) => {
+    try {
+      const result = await Posts.bookmark(args.postId as string)
+      if (result.bookmarked) {
+        UI.success("Post bookmarked")
+      } else {
+        UI.info("Bookmark removed")
+      }
+    } catch (err) {
+      UI.error(`Failed to toggle bookmark: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}

package/src/cli/cmd/comment.ts

@@ -0,0 +1,39 @@
+import type { CommandModule } from "yargs"
+import { Posts } from "../../api/posts"
+import { UI } from "../ui"
+
+export const CommentCommand: CommandModule = {
+  command: "comment <post-id>",
+  describe: "Comment on a post",
+  builder: (yargs) =>
+    yargs
+      .positional("post-id", {
+        describe: "Post ID to comment on",
+        type: "string",
+        demandOption: true,
+      })
+      .option("message", {
+        alias: "m",
+        describe: "Comment text",
+        type: "string",
+      }),
+  handler: async (args) => {
+    let message = args.message as string | undefined
+    if (!message) {
+      message = await UI.input("Enter your comment: ")
+    }
+    if (!message || !message.trim()) {
+      UI.error("Comment cannot be empty")
+      process.exitCode = 1
+      return
+    }
+
+    try {
+      await Posts.comment(args.postId as string, message)
+      UI.success("Comment posted!")
+    } catch (err) {
+      UI.error(`Failed to post comment: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}