optimal-cli 1.0.0 → 1.0.1

package/dist/lib/cms/publish-blog.d.ts

@@ -0,0 +1,62 @@
+import 'dotenv/config';
+import { StrapiItem } from './strapi-client.js';
+export interface PublishBlogOptions {
+    slug: string;
+    deployAfter?: boolean;
+    site?: string;
+}
+export interface PublishBlogResult {
+    documentId: string;
+    slug: string;
+    published: boolean;
+    deployUrl?: string;
+}
+export interface BlogPostData {
+    title: string;
+    slug: string;
+    content: string;
+    site: string;
+    tags?: string[];
+    excerpt?: string;
+}
+export interface BlogPostSummary {
+    documentId: string;
+    title: string;
+    slug: string;
+    site: string;
+    createdAt: string;
+}
+/**
+ * Main orchestrator: find a blog post by slug, publish it in Strapi,
+ * and optionally deploy the portfolio site to Vercel.
+ *
+ * @throws If no blog post is found for the given slug.
+ *
+ * @example
+ *   const result = await publishBlog({ slug: 'copper-investment-thesis-2026', deployAfter: true })
+ *   console.log(result.deployUrl) // https://portfolio-2026.vercel.app
+ */
+export declare function publishBlog(opts: PublishBlogOptions): Promise<PublishBlogResult>;
+/**
+ * Create a new blog post draft in Strapi.
+ *
+ * @example
+ *   const post = await createBlogPost({
+ *     title: 'Copper Investment Thesis 2026',
+ *     slug: 'copper-investment-thesis-2026',
+ *     content: '## Overview\n...',
+ *     site: 'portfolio',
+ *     tags: ['Automated Report'],
+ *   })
+ */
+export declare function createBlogPost(data: BlogPostData): Promise<StrapiItem>;
+/**
+ * List unpublished blog post drafts from Strapi, optionally filtered by site.
+ *
+ * @param site - Optional site key to filter by (e.g. 'portfolio', 'insurance').
+ *
+ * @example
+ *   const drafts = await listBlogDrafts('portfolio')
+ *   drafts.forEach(d => console.log(d.slug, d.createdAt))
+ */
+export declare function listBlogDrafts(site?: string): Promise<BlogPostSummary[]>;

package/dist/lib/cms/publish-blog.js

@@ -0,0 +1,74 @@
+import 'dotenv/config';
+import { deploy } from '../infra/deploy.js';
+import { strapiGet, strapiPost, findBySlug, publish, } from './strapi-client.js';
+// ── Functions ─────────────────────────────────────────────────────────
+/**
+ * Main orchestrator: find a blog post by slug, publish it in Strapi,
+ * and optionally deploy the portfolio site to Vercel.
+ *
+ * @throws If no blog post is found for the given slug.
+ *
+ * @example
+ *   const result = await publishBlog({ slug: 'copper-investment-thesis-2026', deployAfter: true })
+ *   console.log(result.deployUrl) // https://portfolio-2026.vercel.app
+ */
+export async function publishBlog(opts) {
+    const { slug, deployAfter = false } = opts;
+    const item = await findBySlug('blog-posts', slug);
+    if (!item) {
+        throw new Error(`Blog post not found for slug: "${slug}"`);
+    }
+    const { documentId } = item;
+    await publish('blog-posts', documentId);
+    let deployUrl;
+    if (deployAfter) {
+        deployUrl = await deploy('portfolio', true);
+    }
+    return {
+        documentId,
+        slug,
+        published: true,
+        ...(deployUrl !== undefined ? { deployUrl } : {}),
+    };
+}
+/**
+ * Create a new blog post draft in Strapi.
+ *
+ * @example
+ *   const post = await createBlogPost({
+ *     title: 'Copper Investment Thesis 2026',
+ *     slug: 'copper-investment-thesis-2026',
+ *     content: '## Overview\n...',
+ *     site: 'portfolio',
+ *     tags: ['Automated Report'],
+ *   })
+ */
+export async function createBlogPost(data) {
+    return strapiPost('/api/blog-posts', data);
+}
+/**
+ * List unpublished blog post drafts from Strapi, optionally filtered by site.
+ *
+ * @param site - Optional site key to filter by (e.g. 'portfolio', 'insurance').
+ *
+ * @example
+ *   const drafts = await listBlogDrafts('portfolio')
+ *   drafts.forEach(d => console.log(d.slug, d.createdAt))
+ */
+export async function listBlogDrafts(site) {
+    const params = {
+        status: 'draft',
+        'sort': 'createdAt:desc',
+    };
+    if (site) {
+        params['filters[site][$eq]'] = site;
+    }
+    const result = await strapiGet('/api/blog-posts', params);
+    return result.data.map((item) => ({
+        documentId: item.documentId,
+        title: String(item.title ?? ''),
+        slug: String(item.slug ?? ''),
+        site: String(item.site ?? ''),
+        createdAt: String(item.createdAt ?? ''),
+    }));
+}

package/dist/lib/cms/strapi-client.d.ts

@@ -0,0 +1,123 @@
+import 'dotenv/config';
+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 declare class StrapiClientError extends Error {
+    status: number;
+    strapiError?: StrapiError | undefined;
+    constructor(message: string, status: number, strapiError?: StrapiError | undefined);
+}
+/**
+ * GET a Strapi endpoint with optional query params.
+ * Returns the full parsed JSON response.
+ *
+ * @example
+ *   const result = await strapiGet('/api/newsletters', { 'status': 'draft' })
+ */
+export declare function strapiGet<T = StrapiPage>(endpoint: string, params?: Record<string, string>): Promise<T>;
+/**
+ * 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 declare function strapiPost(endpoint: string, data: Record<string, unknown>): Promise<StrapiItem>;
+/**
+ * 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 declare function strapiPut(endpoint: string, documentId: string, data: Record<string, unknown>): Promise<StrapiItem>;
+/**
+ * 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 declare function strapiDelete(endpoint: string, documentId: string): Promise<void>;
+/**
+ * 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 declare function strapiUploadFile(filePath: string, refData?: {
+    ref: string;
+    refId: string;
+    field: string;
+}): Promise<StrapiItem[]>;
+/**
+ * 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 declare function listByBrand(contentType: string, brand: string, status?: 'draft' | 'published'): Promise<StrapiPage>;
+/**
+ * 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 declare function findBySlug(contentType: string, slug: string): Promise<StrapiItem | null>;
+/**
+ * Publish an item by setting publishedAt via PUT.
+ *
+ * @example
+ *   await publish('newsletters', 'abc123-def456')
+ */
+export declare function publish(contentType: string, documentId: string): Promise<StrapiItem>;
+/**
+ * Unpublish (revert to draft) by clearing publishedAt.
+ *
+ * @example
+ *   await unpublish('newsletters', 'abc123-def456')
+ */
+export declare function unpublish(contentType: string, documentId: string): Promise<StrapiItem>;

package/dist/lib/cms/strapi-client.js

@@ -0,0 +1,213 @@
+import 'dotenv/config';
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+export class StrapiClientError extends Error {
+    status;
+    strapiError;
+    constructor(message, status, strapiError) {
+        super(message);
+        this.status = status;
+        this.strapiError = strapiError;
+        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(path, opts = {}) {
+    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;
+        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;
+    return res.json();
+}
+// ── 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(endpoint, params) {
+    const qs = params ? new URLSearchParams(params).toString() : '';
+    const path = qs ? `${endpoint}?${qs}` : endpoint;
+    return request(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, data) {
+    const result = await request(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, documentId, data) {
+    const result = await request(`${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, documentId) {
+    await request(`${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, refData) {
+    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;
+        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();
+}
+// ── 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, brand, status) {
+    const params = {
+        'filters[brand][$eq]': brand,
+        'sort': 'createdAt:desc',
+    };
+    if (status) {
+        params['status'] = status;
+    }
+    return strapiGet(`/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, slug) {
+    const result = await strapiGet(`/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, documentId) {
+    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, documentId) {
+    return strapiPut(`/api/${contentType}`, documentId, {
+        publishedAt: null,
+    });
+}

package/dist/lib/config/registry.d.ts

@@ -0,0 +1,17 @@
+import { getSupabase } from '../supabase.js';
+import { type OptimalConfigV1 } from './schema.js';
+export declare function setRegistrySupabaseProviderForTests(provider: typeof getSupabase): void;
+export declare function resetRegistrySupabaseProviderForTests(): void;
+export declare function ensureConfigDir(): Promise<void>;
+export declare function getLocalConfigPath(): string;
+export declare function getHistoryPath(): string;
+export declare function readLocalConfig(): Promise<OptimalConfigV1 | null>;
+export declare function writeLocalConfig(config: OptimalConfigV1): Promise<void>;
+export declare function hashConfig(config: OptimalConfigV1): string;
+export declare function appendHistory(entry: string): Promise<void>;
+export type RegistrySyncResult = {
+    ok: boolean;
+    message: string;
+};
+export declare function pullRegistryProfile(profile?: string): Promise<RegistrySyncResult>;
+export declare function pushRegistryProfile(profile?: string, force?: boolean, agent?: string): Promise<RegistrySyncResult>;

package/dist/lib/config/registry.js

@@ -0,0 +1,182 @@
+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 } from './schema.js';
+const DIR = join(homedir(), '.optimal');
+const LOCAL_CONFIG_PATH = join(DIR, 'optimal.config.json');
+const HISTORY_PATH = join(DIR, 'config-history.log');
+const REGISTRY_TABLE = 'cli_config_registry';
+let supabaseProvider = getSupabase;
+function getGlobalProviderOverride() {
+    const candidate = globalThis.__optimalRegistrySupabaseProvider;
+    return candidate ?? null;
+}
+function getActiveSupabaseProvider() {
+    return getGlobalProviderOverride() ?? supabaseProvider;
+}
+export function setRegistrySupabaseProviderForTests(provider) {
+    supabaseProvider = provider;
+    globalThis.__optimalRegistrySupabaseProvider = provider;
+}
+export function resetRegistrySupabaseProviderForTests() {
+    supabaseProvider = getSupabase;
+    delete globalThis.__optimalRegistrySupabaseProvider;
+}
+export async function ensureConfigDir() {
+    await mkdir(DIR, { recursive: true });
+}
+export function getLocalConfigPath() {
+    return LOCAL_CONFIG_PATH;
+}
+export function getHistoryPath() {
+    return HISTORY_PATH;
+}
+export async function readLocalConfig() {
+    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) {
+    await ensureConfigDir();
+    await writeFile(LOCAL_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+}
+export function hashConfig(config) {
+    const payload = JSON.stringify(config);
+    return createHash('sha256').update(payload).digest('hex');
+}
+export async function appendHistory(entry) {
+    await ensureConfigDir();
+    await writeFile(HISTORY_PATH, `${entry}\n`, { encoding: 'utf-8', flag: 'a' });
+}
+function resolveOwner(local) {
+    return local?.profile.owner || process.env.OPTIMAL_CONFIG_OWNER || null;
+}
+function parseEpoch(input) {
+    if (!input)
+        return 0;
+    const ts = Date.parse(input);
+    return Number.isNaN(ts) ? 0 : ts;
+}
+export async function pullRegistryProfile(profile = 'default') {
+    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;
+        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) {
+    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;
+            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 = {
+            ...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)}`,
+        };
+    }
+}