optimal-cli 0.1.0

package/dist/lib/config.d.ts

@@ -0,0 +1,55 @@
+interface ConfigRecord {
+    id: string;
+    agent_name: string;
+    config_json: Record<string, unknown>;
+    version: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Initialize local config directory
+ */
+export declare function initConfigDir(): void;
+/**
+ * Load local openclaw.json
+ */
+export declare function loadLocalConfig(): Record<string, unknown> | null;
+/**
+ * Save config to local openclaw.json
+ */
+export declare function saveLocalConfig(config: Record<string, unknown>): void;
+/**
+ * Push current openclaw.json to Supabase
+ */
+export declare function pushConfig(agentName: string): Promise<{
+    id: string;
+    version: string;
+}>;
+/**
+ * Pull config from Supabase and save to local openclaw.json
+ */
+export declare function pullConfig(agentName: string): Promise<ConfigRecord>;
+/**
+ * List all saved agent configs
+ */
+export declare function listConfigs(): Promise<Array<{
+    agent_name: string;
+    version: string;
+    updated_at: string;
+}>>;
+/**
+ * Compare local config with cloud version
+ */
+export declare function diffConfig(agentName: string): Promise<{
+    local: Record<string, unknown> | null;
+    cloud: ConfigRecord | null;
+    differences: string[];
+}>;
+/**
+ * Sync config (two-way merge)
+ */
+export declare function syncConfig(agentName: string): Promise<{
+    action: 'pushed' | 'pulled' | 'merged' | 'none';
+    message: string;
+}>;
+export {};

package/dist/lib/config.js

@@ -0,0 +1,206 @@
+import { createClient } from '@supabase/supabase-js';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CONFIG_DIR = join(homedir(), '.optimal');
+const LOCAL_CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+const OPENCLAW_CONFIG_PATH = join(homedir(), '.openclaw', 'openclaw.json');
+// Get Supabase client for OptimalOS instance (stores CLI configs)
+function getOptimalSupabase() {
+    const url = process.env.OPTIMAL_SUPABASE_URL;
+    const key = process.env.OPTIMAL_SUPABASE_SERVICE_KEY;
+    if (!url || !key) {
+        throw new Error('OPTIMAL_SUPABASE_URL and OPTIMAL_SUPABASE_SERVICE_KEY must be set');
+    }
+    return createClient(url, key);
+}
+/**
+ * Initialize local config directory
+ */
+export function initConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        import('node:fs').then(fs => fs.mkdirSync(CONFIG_DIR, { recursive: true }));
+    }
+}
+/**
+ * Load local openclaw.json
+ */
+export function loadLocalConfig() {
+    if (!existsSync(OPENCLAW_CONFIG_PATH)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(OPENCLAW_CONFIG_PATH, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save config to local openclaw.json
+ */
+export function saveLocalConfig(config) {
+    writeFileSync(OPENCLAW_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+/**
+ * Push current openclaw.json to Supabase
+ */
+export async function pushConfig(agentName) {
+    const supabase = getOptimalSupabase();
+    const config = loadLocalConfig();
+    if (!config) {
+        throw new Error(`No config found at ${OPENCLAW_CONFIG_PATH}`);
+    }
+    // Generate version timestamp
+    const version = new Date().toISOString();
+    // Check if config exists for this agent
+    const { data: existing } = await supabase
+        .from('agent_configs')
+        .select('id')
+        .eq('agent_name', agentName)
+        .single();
+    let result;
+    if (existing) {
+        // Update existing
+        const { data, error } = await supabase
+            .from('agent_configs')
+            .update({
+            config_json: config,
+            version,
+            updated_at: version,
+        })
+            .eq('id', existing.id)
+            .select()
+            .single();
+        if (error)
+            throw error;
+        result = data;
+    }
+    else {
+        // Insert new
+        const { data, error } = await supabase
+            .from('agent_configs')
+            .insert({
+            agent_name: agentName,
+            config_json: config,
+            version,
+        })
+            .select()
+            .single();
+        if (error)
+            throw error;
+        result = data;
+    }
+    return { id: result.id, version };
+}
+/**
+ * Pull config from Supabase and save to local openclaw.json
+ */
+export async function pullConfig(agentName) {
+    const supabase = getOptimalSupabase();
+    const { data, error } = await supabase
+        .from('agent_configs')
+        .select('*')
+        .eq('agent_name', agentName)
+        .order('updated_at', { ascending: false })
+        .limit(1)
+        .single();
+    if (error) {
+        throw new Error(`No config found for agent: ${agentName}`);
+    }
+    // Save to local
+    saveLocalConfig(data.config_json);
+    return data;
+}
+/**
+ * List all saved agent configs
+ */
+export async function listConfigs() {
+    const supabase = getOptimalSupabase();
+    const { data, error } = await supabase
+        .from('agent_configs')
+        .select('agent_name, version, updated_at')
+        .order('updated_at', { ascending: false });
+    if (error) {
+        throw new Error(`Failed to list configs: ${error.message}`);
+    }
+    return data || [];
+}
+/**
+ * Compare local config with cloud version
+ */
+export async function diffConfig(agentName) {
+    const local = loadLocalConfig();
+    let cloud = null;
+    try {
+        const supabase = getOptimalSupabase();
+        const { data } = await supabase
+            .from('agent_configs')
+            .select('*')
+            .eq('agent_name', agentName)
+            .single();
+        cloud = data;
+    }
+    catch {
+        // Cloud config doesn't exist
+    }
+    const differences = [];
+    if (!local && !cloud) {
+        differences.push('No local or cloud config found');
+    }
+    else if (!local) {
+        differences.push('No local config (cloud exists)');
+    }
+    else if (!cloud) {
+        differences.push('No cloud config (local exists)');
+    }
+    else {
+        // Simple diff on top-level keys
+        const localKeys = Object.keys(local).sort();
+        const cloudKeys = Object.keys(cloud.config_json).sort();
+        if (JSON.stringify(localKeys) !== JSON.stringify(cloudKeys)) {
+            differences.push('Top-level keys differ');
+        }
+        // Check version
+        const localMeta = local.meta;
+        if (localMeta?.lastTouchedVersion !== cloud.version) {
+            differences.push(`Version mismatch: local=${localMeta?.lastTouchedVersion}, cloud=${cloud.version}`);
+        }
+    }
+    return { local, cloud, differences };
+}
+/**
+ * Sync config (two-way merge)
+ */
+export async function syncConfig(agentName) {
+    const { local, cloud, differences } = await diffConfig(agentName);
+    if (!local && !cloud) {
+        return { action: 'none', message: 'No configs to sync' };
+    }
+    if (!cloud) {
+        // Only local exists - push
+        const result = await pushConfig(agentName);
+        return { action: 'pushed', message: `Pushed to cloud (version ${result.version})` };
+    }
+    if (!local) {
+        // Only cloud exists - pull
+        await pullConfig(agentName);
+        return { action: 'pulled', message: `Pulled from cloud (version ${cloud.version})` };
+    }
+    // Both exist - compare timestamps
+    const localTime = local.meta?.lastTouchedAt || '1970-01-01';
+    const localVersion = local.meta?.lastTouchedVersion || 'unknown';
+    const cloudTime = cloud.updated_at;
+    if (localTime > cloudTime) {
+        const result = await pushConfig(agentName);
+        return { action: 'pushed', message: `Local is newer - pushed to cloud (version ${result.version})` };
+    }
+    else if (cloudTime > localTime) {
+        await pullConfig(agentName);
+        return { action: 'pulled', message: `Cloud is newer - pulled from cloud (version ${cloud.version})` };
+    }
+    else {
+        return { action: 'none', message: 'Configs are in sync' };
+    }
+}

package/dist/lib/infra/deploy.d.ts

@@ -0,0 +1,29 @@
+/**
+ * List all available app names that can be deployed.
+ */
+export declare function listApps(): string[];
+/**
+ * Resolve an app name to its absolute filesystem path.
+ * Throws if the app name is unknown.
+ */
+export declare function getAppPath(appName: string): string;
+/**
+ * Deploy an app to Vercel using the `vercel` CLI.
+ *
+ * Uses `execFile` (not `exec`) to avoid shell injection.
+ * The `--cwd` flag tells Vercel which project directory to deploy.
+ *
+ * @param appName - Short name from APP_PATHS (e.g. 'portfolio', 'dashboard-returnpro')
+ * @param prod - If true, deploys to production (--prod flag). Otherwise preview.
+ * @returns The deployment URL printed by Vercel CLI.
+ */
+export declare function deploy(appName: string, prod?: boolean): Promise<string>;
+/**
+ * Run the Optimal workstation health check script.
+ *
+ * Checks: n8n, Affine (Docker + HTTP), Strapi CMS (systemd + HTTP),
+ * Git repo sync status, Docker containers, and OptimalOS dev server.
+ *
+ * @returns The full text output of the health check script.
+ */
+export declare function healthCheck(): Promise<string>;

package/dist/lib/infra/deploy.js

@@ -0,0 +1,58 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+/** Map of short app names to absolute filesystem paths. */
+const APP_PATHS = {
+    'dashboard-returnpro': '/home/optimal/dashboard-returnpro',
+    'optimalos': '/home/optimal/optimalos',
+    'portfolio': '/home/optimal/portfolio-2026',
+    'newsletter-preview': '/home/optimal/projects/newsletter-preview',
+    'wes': '/home/optimal/wes-dashboard',
+};
+/**
+ * List all available app names that can be deployed.
+ */
+export function listApps() {
+    return Object.keys(APP_PATHS);
+}
+/**
+ * Resolve an app name to its absolute filesystem path.
+ * Throws if the app name is unknown.
+ */
+export function getAppPath(appName) {
+    const appPath = APP_PATHS[appName];
+    if (!appPath) {
+        throw new Error(`Unknown app: ${appName}. Available: ${Object.keys(APP_PATHS).join(', ')}`);
+    }
+    return appPath;
+}
+/**
+ * Deploy an app to Vercel using the `vercel` CLI.
+ *
+ * Uses `execFile` (not `exec`) to avoid shell injection.
+ * The `--cwd` flag tells Vercel which project directory to deploy.
+ *
+ * @param appName - Short name from APP_PATHS (e.g. 'portfolio', 'dashboard-returnpro')
+ * @param prod - If true, deploys to production (--prod flag). Otherwise preview.
+ * @returns The deployment URL printed by Vercel CLI.
+ */
+export async function deploy(appName, prod = false) {
+    const appPath = getAppPath(appName);
+    const args = prod
+        ? ['--prod', '--cwd', appPath]
+        : ['--cwd', appPath];
+    const { stdout } = await run('vercel', args, { timeout: 120_000 });
+    return stdout.trim();
+}
+/**
+ * Run the Optimal workstation health check script.
+ *
+ * Checks: n8n, Affine (Docker + HTTP), Strapi CMS (systemd + HTTP),
+ * Git repo sync status, Docker containers, and OptimalOS dev server.
+ *
+ * @returns The full text output of the health check script.
+ */
+export async function healthCheck() {
+    const { stdout } = await run('bash', ['/home/optimal/scripts/health-check.sh'], { timeout: 30_000 });
+    return stdout.trim();
+}

package/dist/lib/infra/migrate.d.ts

@@ -0,0 +1,34 @@
+import 'dotenv/config';
+export interface MigrateOptions {
+    target: 'returnpro' | 'optimalos';
+    dryRun?: boolean;
+}
+export interface MigrateResult {
+    success: boolean;
+    target: string;
+    output: string;
+    errors: string;
+}
+/**
+ * Run `supabase db push --linked` (or `--dry-run` if requested) against the
+ * given target project directory.
+ *
+ * Uses `execFile` (not `exec`) to avoid shell injection.
+ * The `cwd` option switches the Supabase CLI into the correct project.
+ */
+export declare function migrateDb(opts: MigrateOptions): Promise<MigrateResult>;
+/**
+ * List migration `.sql` files in the target's `supabase/migrations/` directory,
+ * sorted chronologically (by filename, which starts with a YYYYMMDDHHMMSS prefix).
+ *
+ * Returns only filenames, not full paths.
+ */
+export declare function listPendingMigrations(target: 'returnpro' | 'optimalos'): Promise<string[]>;
+/**
+ * Create a new empty migration file in the target's `supabase/migrations/`
+ * directory.
+ *
+ * The filename format is `{YYYYMMDDHHMMSS}_{name}.sql` (UTC timestamp).
+ * Returns the full absolute path of the created file.
+ */
+export declare function createMigration(target: 'returnpro' | 'optimalos', name: string): Promise<string>;

package/dist/lib/infra/migrate.js

@@ -0,0 +1,103 @@
+import 'dotenv/config';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const run = promisify(execFile);
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Hardcoded project directories — these live on Carlos's machine. */
+const PROJECT_DIRS = {
+    returnpro: '/home/optimal/dashboard-returnpro',
+    optimalos: '/home/optimal/optimalos',
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function getProjectDir(target) {
+    return PROJECT_DIRS[target];
+}
+function migrationsDir(target) {
+    return join(getProjectDir(target), 'supabase', 'migrations');
+}
+/**
+ * Generate a timestamp string in YYYYMMDDHHMMSS format (UTC).
+ */
+function timestamp() {
+    const now = new Date();
+    const pad = (n, len = 2) => String(n).padStart(len, '0');
+    return [
+        now.getUTCFullYear(),
+        pad(now.getUTCMonth() + 1),
+        pad(now.getUTCDate()),
+        pad(now.getUTCHours()),
+        pad(now.getUTCMinutes()),
+        pad(now.getUTCSeconds()),
+    ].join('');
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Run `supabase db push --linked` (or `--dry-run` if requested) against the
+ * given target project directory.
+ *
+ * Uses `execFile` (not `exec`) to avoid shell injection.
+ * The `cwd` option switches the Supabase CLI into the correct project.
+ */
+export async function migrateDb(opts) {
+    const { target, dryRun = false } = opts;
+    const projectDir = getProjectDir(target);
+    const args = ['db', 'push', '--linked'];
+    if (dryRun)
+        args.push('--dry-run');
+    try {
+        const { stdout, stderr } = await run('supabase', args, {
+            cwd: projectDir,
+            timeout: 120_000,
+        });
+        return {
+            success: true,
+            target,
+            output: stdout.trim(),
+            errors: stderr.trim(),
+        };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            success: false,
+            target,
+            output: (e.stdout ?? '').trim(),
+            errors: (e.stderr ?? e.message ?? String(err)).trim(),
+        };
+    }
+}
+/**
+ * List migration `.sql` files in the target's `supabase/migrations/` directory,
+ * sorted chronologically (by filename, which starts with a YYYYMMDDHHMMSS prefix).
+ *
+ * Returns only filenames, not full paths.
+ */
+export async function listPendingMigrations(target) {
+    const dir = migrationsDir(target);
+    const entries = await readdir(dir);
+    return entries
+        .filter((f) => f.endsWith('.sql'))
+        .sort(); // lexicographic == chronological given the YYYYMMDDHHMMSS prefix
+}
+/**
+ * Create a new empty migration file in the target's `supabase/migrations/`
+ * directory.
+ *
+ * The filename format is `{YYYYMMDDHHMMSS}_{name}.sql` (UTC timestamp).
+ * Returns the full absolute path of the created file.
+ */
+export async function createMigration(target, name) {
+    const sanitized = name.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+    const filename = `${timestamp()}_${sanitized}.sql`;
+    const fullPath = join(migrationsDir(target), filename);
+    await writeFile(fullPath, `-- Migration: ${sanitized}\n-- Target: ${target}\n-- Created: ${new Date().toISOString()}\n\n`, { encoding: 'utf8' });
+    return fullPath;
+}

package/dist/lib/kanban.d.ts

@@ -0,0 +1,46 @@
+export interface CliTask {
+    id: string;
+    project_id: string;
+    parent_id: string | null;
+    title: string;
+    description: string | null;
+    status: 'backlog' | 'ready' | 'in_progress' | 'blocked' | 'review' | 'done' | 'canceled';
+    priority: 1 | 2 | 3 | 4;
+    assigned_agent: string | null;
+    skill_ref: string | null;
+    source_repo: string | null;
+    blocked_by: string[] | null;
+    labels: string[];
+    metadata: Record<string, unknown>;
+    started_at: string | null;
+    completed_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface CreateTaskInput {
+    project_slug: string;
+    title: string;
+    description?: string;
+    priority?: 1 | 2 | 3 | 4;
+    skill_ref?: string;
+    source_repo?: string;
+    labels?: string[];
+    parent_id?: string;
+    blocked_by?: string[];
+}
+export declare function getProjectBySlug(slug: string): Promise<any>;
+export declare function createTask(input: CreateTaskInput): Promise<CliTask>;
+export declare function updateTask(taskId: string, updates: Partial<Pick<CliTask, 'status' | 'assigned_agent' | 'priority' | 'metadata' | 'labels'>>): Promise<CliTask>;
+export declare function getNextTask(projectSlug: string, agentName: string): Promise<CliTask | null>;
+export declare function getBoard(projectSlug: string): Promise<CliTask[]>;
+export declare function logActivity(taskId: string, entry: {
+    agent: string;
+    action: string;
+    message?: string;
+    metadata?: Record<string, unknown>;
+}): Promise<void>;
+export declare function logSkillExecution(skillName: string, agent: string, result: {
+    success: boolean;
+    message: string;
+    metadata?: Record<string, unknown>;
+}): Promise<void>;

package/dist/lib/kanban.js

@@ -0,0 +1,118 @@
+import { getSupabase } from './supabase.js';
+const sb = () => getSupabase('optimal');
+// --- Projects ---
+export async function getProjectBySlug(slug) {
+    const { data, error } = await sb()
+        .from('cli_projects')
+        .select('*')
+        .eq('slug', slug)
+        .single();
+    if (error)
+        throw new Error(`Project not found: ${slug} — ${error.message}`);
+    return data;
+}
+// --- Tasks ---
+export async function createTask(input) {
+    const project = await getProjectBySlug(input.project_slug);
+    const { data, error } = await sb()
+        .from('cli_tasks')
+        .insert({
+        project_id: project.id,
+        title: input.title,
+        description: input.description ?? null,
+        priority: input.priority ?? 3,
+        skill_ref: input.skill_ref ?? null,
+        source_repo: input.source_repo ?? null,
+        labels: input.labels ?? [],
+        parent_id: input.parent_id ?? null,
+        blocked_by: input.blocked_by ?? null,
+    })
+        .select()
+        .single();
+    if (error)
+        throw new Error(`Failed to create task: ${error.message}`);
+    return data;
+}
+export async function updateTask(taskId, updates) {
+    const { data, error } = await sb()
+        .from('cli_tasks')
+        .update(updates)
+        .eq('id', taskId)
+        .select()
+        .single();
+    if (error)
+        throw new Error(`Failed to update task ${taskId}: ${error.message}`);
+    return data;
+}
+export async function getNextTask(projectSlug, agentName) {
+    const project = await getProjectBySlug(projectSlug);
+    const { data, error } = await sb()
+        .from('cli_tasks')
+        .select('*')
+        .eq('project_id', project.id)
+        .in('status', ['ready', 'backlog'])
+        .is('assigned_agent', null)
+        .order('priority', { ascending: true })
+        .order('created_at', { ascending: true })
+        .limit(10);
+    if (error)
+        throw new Error(`Failed to fetch tasks: ${error.message}`);
+    if (!data || data.length === 0)
+        return null;
+    for (const task of data) {
+        if (!task.blocked_by || task.blocked_by.length === 0)
+            return task;
+        const { data: blockers } = await sb()
+            .from('cli_tasks')
+            .select('id, status')
+            .in('id', task.blocked_by);
+        const allDone = blockers?.every(b => b.status === 'done' || b.status === 'canceled');
+        if (allDone)
+            return task;
+    }
+    return null;
+}
+export async function getBoard(projectSlug) {
+    const project = await getProjectBySlug(projectSlug);
+    const { data, error } = await sb()
+        .from('cli_tasks')
+        .select('*')
+        .eq('project_id', project.id)
+        .not('status', 'eq', 'canceled')
+        .order('priority', { ascending: true })
+        .order('created_at', { ascending: true });
+    if (error)
+        throw new Error(`Failed to fetch board: ${error.message}`);
+    return (data ?? []);
+}
+// --- Logging ---
+export async function logActivity(taskId, entry) {
+    const { error } = await sb()
+        .from('cli_task_logs')
+        .insert({
+        task_id: taskId,
+        agent: entry.agent,
+        action: entry.action,
+        message: entry.message ?? null,
+        metadata: entry.metadata ?? {},
+    });
+    if (error)
+        throw new Error(`Failed to log activity: ${error.message}`);
+}
+export async function logSkillExecution(skillName, agent, result) {
+    const { data: tasks } = await sb()
+        .from('cli_tasks')
+        .select('id')
+        .eq('skill_ref', skillName)
+        .eq('status', 'in_progress')
+        .limit(1);
+    const taskId = tasks?.[0]?.id;
+    if (taskId) {
+        await logActivity(taskId, {
+            agent,
+            action: result.success ? 'skill_success' : 'skill_error',
+            message: result.message,
+            metadata: result.metadata,
+        });
+    }
+}