optimal-cli 1.0.1 → 1.1.0

package/lib/cms/strapi-client.ts

@@ -0,0 +1,302 @@
+import 'dotenv/config'
+import { readFileSync } from 'node:fs'
+import { basename } from 'node:path'
+
+// ── Types ────────────────────────────────────────────────────────────
+
+export interface StrapiItem {
+  id: number
+  documentId: string
+  [key: string]: unknown
+}
+
+export interface StrapiPagination {
+  page: number
+  pageSize: number
+  pageCount: number
+  total: number
+}
+
+export interface StrapiPage {
+  data: StrapiItem[]
+  meta: { pagination: StrapiPagination }
+}
+
+export interface StrapiError {
+  status: number
+  name: string
+  message: string
+  details?: Record<string, unknown>
+}
+
+export class StrapiClientError extends Error {
+  constructor(
+    message: string,
+    public status: number,
+    public strapiError?: StrapiError,
+  ) {
+    super(message)
+    this.name = 'StrapiClientError'
+  }
+}
+
+// ── Config ───────────────────────────────────────────────────────────
+
+function getConfig() {
+  const url = process.env.STRAPI_URL
+  const token = process.env.STRAPI_API_TOKEN
+  if (!url || !token) {
+    throw new Error('Missing env vars: STRAPI_URL, STRAPI_API_TOKEN')
+  }
+  return { url: url.replace(/\/+$/, ''), token }
+}
+
+// ── Internal request helper ──────────────────────────────────────────
+
+async function request<T>(
+  path: string,
+  opts: RequestInit = {},
+): Promise<T> {
+  const { url, token } = getConfig()
+  const fullUrl = `${url}${path}`
+
+  const res = await fetch(fullUrl, {
+    ...opts,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      ...opts.headers,
+    },
+  })
+
+  if (!res.ok) {
+    let strapiErr: StrapiError | undefined
+    try {
+      const body = await res.json()
+      strapiErr = body?.error
+    } catch {
+      // non-JSON error body
+    }
+    throw new StrapiClientError(
+      strapiErr?.message ?? `Strapi ${res.status}: ${res.statusText}`,
+      res.status,
+      strapiErr,
+    )
+  }
+
+  if (res.status === 204) return undefined as T
+  return res.json() as Promise<T>
+}
+
+// ── CRUD Functions ───────────────────────────────────────────────────
+
+/**
+ * GET a Strapi endpoint with optional query params.
+ * Returns the full parsed JSON response.
+ *
+ * @example
+ *   const result = await strapiGet('/api/newsletters', { 'status': 'draft' })
+ */
+export async function strapiGet<T = StrapiPage>(
+  endpoint: string,
+  params?: Record<string, string>,
+): Promise<T> {
+  const qs = params ? new URLSearchParams(params).toString() : ''
+  const path = qs ? `${endpoint}?${qs}` : endpoint
+  return request<T>(path)
+}
+
+/**
+ * POST to a Strapi endpoint. Wraps data in `{ data }` per Strapi v5 convention.
+ * Returns the created item.
+ *
+ * @example
+ *   const item = await strapiPost('/api/social-posts', {
+ *     headline: 'New post',
+ *     brand: 'LIFEINSUR',
+ *   })
+ */
+export async function strapiPost(
+  endpoint: string,
+  data: Record<string, unknown>,
+): Promise<StrapiItem> {
+  const result = await request<{ data: StrapiItem }>(endpoint, {
+    method: 'POST',
+    body: JSON.stringify({ data }),
+  })
+  return result.data
+}
+
+/**
+ * PUT to a Strapi endpoint by documentId. Wraps data in `{ data }`.
+ *
+ * IMPORTANT: Strapi v5 uses documentId (UUID string), NOT numeric id.
+ *
+ * @example
+ *   await strapiPut('/api/newsletters', 'abc123-def456', { subject_line: 'Updated' })
+ */
+export async function strapiPut(
+  endpoint: string,
+  documentId: string,
+  data: Record<string, unknown>,
+): Promise<StrapiItem> {
+  const result = await request<{ data: StrapiItem }>(`${endpoint}/${documentId}`, {
+    method: 'PUT',
+    body: JSON.stringify({ data }),
+  })
+  return result.data
+}
+
+/**
+ * DELETE a Strapi item by documentId.
+ *
+ * IMPORTANT: Strapi v5 uses documentId (UUID string), NOT numeric id.
+ *
+ * @example
+ *   await strapiDelete('/api/social-posts', 'abc123-def456')
+ */
+export async function strapiDelete(
+  endpoint: string,
+  documentId: string,
+): Promise<void> {
+  await request<void>(`${endpoint}/${documentId}`, { method: 'DELETE' })
+}
+
+/**
+ * Upload a file to Strapi's `/api/upload` endpoint via multipart form.
+ *
+ * Optionally link the upload to an existing entry via `refData`:
+ *   - ref: content type UID (e.g. 'api::newsletter.newsletter')
+ *   - refId: documentId of the entry to attach to
+ *   - field: field name on the content type (e.g. 'cover_image')
+ *
+ * @example
+ *   const uploaded = await strapiUploadFile('/path/to/image.png')
+ *   const linked = await strapiUploadFile('/path/to/cover.jpg', {
+ *     ref: 'api::blog-post.blog-post',
+ *     refId: 'abc123',
+ *     field: 'cover',
+ *   })
+ */
+export async function strapiUploadFile(
+  filePath: string,
+  refData?: { ref: string; refId: string; field: string },
+): Promise<StrapiItem[]> {
+  const { url, token } = getConfig()
+
+  const fileBuffer = readFileSync(filePath)
+  const fileName = basename(filePath)
+
+  const formData = new FormData()
+  formData.append('files', new Blob([fileBuffer]), fileName)
+
+  if (refData) {
+    formData.append('ref', refData.ref)
+    formData.append('refId', refData.refId)
+    formData.append('field', refData.field)
+  }
+
+  const res = await fetch(`${url}/api/upload`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      // Do NOT set Content-Type — fetch sets it with the multipart boundary
+    },
+    body: formData,
+  })
+
+  if (!res.ok) {
+    let strapiErr: StrapiError | undefined
+    try {
+      const body = await res.json()
+      strapiErr = body?.error
+    } catch {
+      // non-JSON error body
+    }
+    throw new StrapiClientError(
+      strapiErr?.message ?? `Upload failed ${res.status}: ${res.statusText}`,
+      res.status,
+      strapiErr,
+    )
+  }
+
+  return res.json() as Promise<StrapiItem[]>
+}
+
+// ── Convenience ──────────────────────────────────────────────────────
+
+/**
+ * List items of a content type filtered by brand, with optional status filter.
+ * This is the most common query pattern in Optimal's multi-brand CMS setup.
+ *
+ * Content types: 'newsletters', 'social-posts', 'blog-posts'
+ * Brands: 'CRE-11TRUST', 'LIFEINSUR'
+ * Status: 'draft' or 'published' (Strapi's draftAndPublish)
+ *
+ * @example
+ *   const drafts = await listByBrand('social-posts', 'LIFEINSUR', 'draft')
+ *   const published = await listByBrand('newsletters', 'CRE-11TRUST', 'published')
+ *   const all = await listByBrand('blog-posts', 'CRE-11TRUST')
+ */
+export async function listByBrand(
+  contentType: string,
+  brand: string,
+  status?: 'draft' | 'published',
+): Promise<StrapiPage> {
+  const params: Record<string, string> = {
+    'filters[brand][$eq]': brand,
+    'sort': 'createdAt:desc',
+  }
+  if (status) {
+    params['status'] = status
+  }
+  return strapiGet<StrapiPage>(`/api/${contentType}`, params)
+}
+
+/**
+ * Find a single item by slug within a content type.
+ * Returns null if not found.
+ *
+ * @example
+ *   const post = await findBySlug('blog-posts', 'copper-investment-thesis-2026')
+ */
+export async function findBySlug(
+  contentType: string,
+  slug: string,
+): Promise<StrapiItem | null> {
+  const result = await strapiGet<StrapiPage>(`/api/${contentType}`, {
+    'filters[slug][$eq]': slug,
+    'pagination[pageSize]': '1',
+  })
+  return result.data[0] ?? null
+}
+
+/**
+ * Publish an item by setting publishedAt via PUT.
+ *
+ * @example
+ *   await publish('newsletters', 'abc123-def456')
+ */
+export async function publish(
+  contentType: string,
+  documentId: string,
+): Promise<StrapiItem> {
+  return strapiPut(`/api/${contentType}`, documentId, {
+    publishedAt: new Date().toISOString(),
+  })
+}
+
+/**
+ * Unpublish (revert to draft) by clearing publishedAt.
+ *
+ * @example
+ *   await unpublish('newsletters', 'abc123-def456')
+ */
+export async function unpublish(
+  contentType: string,
+  documentId: string,
+): Promise<StrapiItem> {
+  return strapiPut(`/api/${contentType}`, documentId, {
+    publishedAt: null,
+  })
+}

package/lib/config/registry.ts

@@ -0,0 +1,229 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { createHash } from 'node:crypto'
+import { getSupabase } from '../supabase.js'
+import { assertOptimalConfigV1, type OptimalConfigV1 } from './schema.js'
+
+// Support optional config directory override via env var (useful for testing)
+const CONFIG_DIR = process.env.OPTIMAL_CONFIG_DIR || join(homedir(), '.optimal')
+const LOCAL_CONFIG_PATH = join(CONFIG_DIR, 'optimal.config.json')
+const HISTORY_PATH = join(CONFIG_DIR, 'config-history.log')
+const REGISTRY_TABLE = 'cli_config_registry'
+
+let supabaseProvider: typeof getSupabase = getSupabase
+
+function getGlobalProviderOverride(): typeof getSupabase | null {
+  const candidate = (globalThis as { __optimalRegistrySupabaseProvider?: typeof getSupabase }).__optimalRegistrySupabaseProvider
+  return candidate ?? null
+}
+
+function getActiveSupabaseProvider(): typeof getSupabase {
+  return getGlobalProviderOverride() ?? supabaseProvider
+}
+
+export function setRegistrySupabaseProviderForTests(provider: typeof getSupabase): void {
+  supabaseProvider = provider
+  ;(globalThis as { __optimalRegistrySupabaseProvider?: typeof getSupabase }).__optimalRegistrySupabaseProvider = provider
+}
+
+export function resetRegistrySupabaseProviderForTests(): void {
+  supabaseProvider = getSupabase
+  delete (globalThis as { __optimalRegistrySupabaseProvider?: typeof getSupabase }).__optimalRegistrySupabaseProvider
+}
+
+export async function ensureConfigDir(): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true })
+}
+
+export function getLocalConfigPath(): string {
+  return LOCAL_CONFIG_PATH
+}
+
+export function getHistoryPath(): string {
+  return HISTORY_PATH
+}
+
+export async function readLocalConfig(): Promise<OptimalConfigV1 | null> {
+  if (!existsSync(LOCAL_CONFIG_PATH)) return null
+  const raw = await readFile(LOCAL_CONFIG_PATH, 'utf-8')
+  const parsed = JSON.parse(raw)
+  return assertOptimalConfigV1(parsed)
+}
+
+export async function writeLocalConfig(config: OptimalConfigV1): Promise<void> {
+  await ensureConfigDir()
+  await writeFile(LOCAL_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, 'utf-8')
+}
+
+export function hashConfig(config: OptimalConfigV1): string {
+  const payload = JSON.stringify(config)
+  return createHash('sha256').update(payload).digest('hex')
+}
+
+export async function appendHistory(entry: string): Promise<void> {
+  await ensureConfigDir()
+  await writeFile(HISTORY_PATH, `${entry}\n`, { encoding: 'utf-8', flag: 'a' })
+}
+
+export type RegistrySyncResult = {
+  ok: boolean
+  message: string
+}
+
+type RegistryRow = {
+  owner: string
+  profile: string
+  config_version: string
+  payload: unknown
+  payload_hash: string
+  updated_at: string
+}
+
+function resolveOwner(local: OptimalConfigV1 | null): string | null {
+  return local?.profile.owner || process.env.OPTIMAL_CONFIG_OWNER || null
+}
+
+function parseEpoch(input: string | undefined): number {
+  if (!input) return 0
+  const ts = Date.parse(input)
+  return Number.isNaN(ts) ? 0 : ts
+}
+
+export async function pullRegistryProfile(profile = 'default'): Promise<RegistrySyncResult> {
+  try {
+    const local = await readLocalConfig()
+    const owner = resolveOwner(local)
+    if (!owner) {
+      return {
+        ok: false,
+        message: 'registry pull failed: missing owner (set local config profile.owner or OPTIMAL_CONFIG_OWNER)',
+      }
+    }
+
+    const supabase = getActiveSupabaseProvider()('optimal')
+    const { data, error } = await supabase
+      .from(REGISTRY_TABLE)
+      .select('owner,profile,config_version,payload,payload_hash,updated_at')
+      .eq('owner', owner)
+      .eq('profile', profile)
+      .maybeSingle()
+
+    if (error) {
+      return { ok: false, message: `registry pull failed: ${error.message}` }
+    }
+    if (!data) {
+      return { ok: false, message: `registry pull failed: no remote profile found for owner=${owner} profile=${profile}` }
+    }
+
+    const row = data as RegistryRow
+    const payload = assertOptimalConfigV1(row.payload)
+    await writeLocalConfig(payload)
+
+    const localHash = local ? hashConfig(local) : null
+    const changed = localHash !== row.payload_hash
+
+    return {
+      ok: true,
+      message: changed
+        ? `registry pull ok: wrote owner=${owner} profile=${profile} hash=${row.payload_hash.slice(0, 12)}`
+        : `registry pull ok: local already matched owner=${owner} profile=${profile}`,
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      message: `registry pull failed: ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+}
+
+export async function pushRegistryProfile(profile = 'default', force = false, agent?: string): Promise<RegistrySyncResult> {
+  try {
+    const local = await readLocalConfig()
+    if (!local) {
+      return { ok: false, message: `registry push failed: no local config at ${LOCAL_CONFIG_PATH}` }
+    }
+
+    let owner = resolveOwner(local)
+    if (!owner && agent) {
+      owner = agent
+      local.profile.owner = owner
+    }
+    if (!owner) {
+      return {
+        ok: false,
+        message: 'registry push failed: missing owner (set local config profile.owner, OPTIMAL_CONFIG_OWNER, or use --agent)',
+      }
+    }
+
+    const localHash = hashConfig(local)
+    const supabase = getActiveSupabaseProvider()('optimal')
+
+    const { data: existing, error: readErr } = await supabase
+      .from(REGISTRY_TABLE)
+      .select('owner,profile,config_version,payload,payload_hash,updated_at')
+      .eq('owner', owner)
+      .eq('profile', profile)
+      .maybeSingle()
+
+    if (readErr) {
+      return { ok: false, message: `registry push failed: ${readErr.message}` }
+    }
+
+    if (existing) {
+      const row = existing as RegistryRow
+      if (row.payload_hash !== localHash && !force) {
+        const remotePayload = assertOptimalConfigV1(row.payload)
+        const remoteTs = Math.max(parseEpoch(row.updated_at), parseEpoch(remotePayload.profile.updated_at))
+        const localTs = parseEpoch(local.profile.updated_at)
+
+        if (remoteTs >= localTs) {
+          return {
+            ok: false,
+            message:
+              `registry push conflict: remote is newer/different for owner=${owner} profile=${profile}. ` +
+              'run `optimal config sync pull` or retry with --force',
+          }
+        }
+      }
+    }
+
+    const payload: OptimalConfigV1 = {
+      ...local,
+      profile: {
+        ...local.profile,
+        name: profile,
+        owner,
+        updated_at: new Date().toISOString(),
+      },
+    }
+
+    const { error: upsertErr } = await supabase.from(REGISTRY_TABLE).upsert(
+      {
+        owner,
+        profile,
+        config_version: payload.version,
+        payload,
+        payload_hash: hashConfig(payload),
+        source: 'optimal-cli',
+        updated_by: process.env.USER || 'oracle',
+      },
+      { onConflict: 'owner,profile' },
+    )
+
+    if (upsertErr) {
+      return { ok: false, message: `registry push failed: ${upsertErr.message}` }
+    }
+
+    return {
+      ok: true,
+      message: `registry push ok: owner=${owner} profile=${profile} hash=${hashConfig(payload).slice(0, 12)} force=${force}`,
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      message: `registry push failed: ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+}

package/lib/config/schema.ts

@@ -0,0 +1,58 @@
+export type ConfigSchemaVersion = '1.0.0'
+
+export interface OptimalConfigV1 {
+  version: ConfigSchemaVersion
+  profile: {
+    name: string
+    owner: string
+    updated_at: string
+  }
+  providers: {
+    supabase: {
+      project_ref: string
+      url: string
+      anon_key_present: boolean
+    }
+    strapi: {
+      base_url: string
+      token_present: boolean
+    }
+  }
+  defaults: {
+    brand: string
+    timezone: string
+  }
+  features: {
+    cms: boolean
+    tasks: boolean
+    deploy: boolean
+  }
+}
+
+export function isOptimalConfigV1(value: unknown): value is OptimalConfigV1 {
+  if (!value || typeof value !== 'object') return false
+  const v = value as Record<string, any>
+  return (
+    v.version === '1.0.0' &&
+    typeof v.profile?.name === 'string' &&
+    typeof v.profile?.owner === 'string' &&
+    typeof v.profile?.updated_at === 'string' &&
+    typeof v.providers?.supabase?.project_ref === 'string' &&
+    typeof v.providers?.supabase?.url === 'string' &&
+    typeof v.providers?.supabase?.anon_key_present === 'boolean' &&
+    typeof v.providers?.strapi?.base_url === 'string' &&
+    typeof v.providers?.strapi?.token_present === 'boolean' &&
+    typeof v.defaults?.brand === 'string' &&
+    typeof v.defaults?.timezone === 'string' &&
+    typeof v.features?.cms === 'boolean' &&
+    typeof v.features?.tasks === 'boolean' &&
+    typeof v.features?.deploy === 'boolean'
+  )
+}
+
+export function assertOptimalConfigV1(value: unknown): OptimalConfigV1 {
+  if (!isOptimalConfigV1(value)) {
+    throw new Error('Invalid optimal config payload (v1)')
+  }
+  return value
+}