optimal-cli 1.0.1 → 1.1.0

package/lib/config.ts

@@ -0,0 +1,247 @@
+import { createClient, SupabaseClient } 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(): SupabaseClient {
+  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)
+}
+
+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 function initConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    import('node:fs').then(fs => fs.mkdirSync(CONFIG_DIR, { recursive: true }))
+  }
+}
+
+/**
+ * Load local openclaw.json
+ */
+export function loadLocalConfig(): Record<string, unknown> | null {
+  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: Record<string, unknown>): void {
+  writeFileSync(OPENCLAW_CONFIG_PATH, JSON.stringify(config, null, 2))
+}
+
+/**
+ * Push current openclaw.json to Supabase
+ */
+export async function pushConfig(agentName: string): Promise<{ id: string; version: string }> {
+  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: string): Promise<ConfigRecord> {
+  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 as ConfigRecord
+}
+
+/**
+ * List all saved agent configs
+ */
+export async function listConfigs(): Promise<Array<{ agent_name: string; version: string; updated_at: string }>> {
+  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: string): Promise<{
+  local: Record<string, unknown> | null
+  cloud: ConfigRecord | null
+  differences: string[]
+}> {
+  const local = loadLocalConfig()
+  let cloud: ConfigRecord | null = null
+  
+  try {
+    const supabase = getOptimalSupabase()
+    const { data } = await supabase
+      .from('agent_configs')
+      .select('*')
+      .eq('agent_name', agentName)
+      .single()
+    cloud = data as ConfigRecord
+  } catch {
+    // Cloud config doesn't exist
+  }
+
+  const differences: string[] = []
+  
+  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 as any).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: string): Promise<{
+  action: 'pushed' | 'pulled' | 'merged' | 'none'
+  message: string
+}> {
+  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 as any).meta?.lastTouchedAt || '1970-01-01'
+  const localVersion = (local as any).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/lib/infra/deploy.ts

@@ -0,0 +1,70 @@
+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: Record<string, string> = {
+  '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(): string[] {
+  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: string): string {
+  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: string, prod = false): Promise<string> {
+  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(): Promise<string> {
+  const { stdout } = await run(
+    'bash',
+    ['/home/optimal/scripts/health-check.sh'],
+    { timeout: 30_000 }
+  )
+  return stdout.trim()
+}

package/lib/infra/migrate.ts

@@ -0,0 +1,141 @@
+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)
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface MigrateOptions {
+  target: 'returnpro' | 'optimalos'
+  dryRun?: boolean // if true, just show what would be pushed
+}
+
+export interface MigrateResult {
+  success: boolean
+  target: string
+  output: string
+  errors: string
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Hardcoded project directories — these live on Carlos's machine. */
+const PROJECT_DIRS: Record<'returnpro' | 'optimalos', string> = {
+  returnpro: '/home/optimal/dashboard-returnpro',
+  optimalos: '/home/optimal/optimalos',
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getProjectDir(target: 'returnpro' | 'optimalos'): string {
+  return PROJECT_DIRS[target]
+}
+
+function migrationsDir(target: 'returnpro' | 'optimalos'): string {
+  return join(getProjectDir(target), 'supabase', 'migrations')
+}
+
+/**
+ * Generate a timestamp string in YYYYMMDDHHMMSS format (UTC).
+ */
+function timestamp(): string {
+  const now = new Date()
+  const pad = (n: number, 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: MigrateOptions): Promise<MigrateResult> {
+  const { target, dryRun = false } = opts
+  const projectDir = getProjectDir(target)
+
+  const args: string[] = ['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: unknown) {
+    const e = err as { stdout?: string; stderr?: string; message?: string }
+    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: 'returnpro' | 'optimalos'
+): Promise<string[]> {
+  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: 'returnpro' | 'optimalos',
+  name: string
+): Promise<string> {
+  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/lib/kanban-obsidian.ts

@@ -0,0 +1,232 @@
+/**
+ * Obsidian-backed Kanban board operations
+ * Works directly with markdown task files in the tasks vault
+ */
+import { readFile, writeFile, readdir } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { glob } from 'glob'
+
+const TASKS_DIR = process.env.OPTIMAL_TASKS_DIR || '/home/oracle/Documents/optimal/tasks'
+
+export interface ObsidianTask {
+  id: string
+  title: string
+  description: string
+  status: 'pending' | 'in-progress' | 'done'
+  priority: number
+  owner: string | null
+  assignee: string | null
+  project: string | null
+  tags: string[]
+  createdAt: string | null
+  updatedAt: string | null
+  source: string | null
+  filePath: string
+}
+
+export interface BoardColumn {
+  name: string
+  status: string
+  tasks: ObsidianTask[]
+}
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!fmMatch) return {}
+  
+  const fm: Record<string, string> = {}
+  const lines = fmMatch[1].split('\n')
+  for (const line of lines) {
+    const colonIdx = line.indexOf(':')
+    if (colonIdx === -1) continue
+    const key = line.slice(0, colonIdx).trim()
+    const value = line.slice(colonIdx + 1).trim()
+    fm[key] = value
+  }
+  return fm
+}
+
+function getTaskIdFromFilename(filename: string): string {
+  // filename format: task__description__hash.md
+  return filename.replace(/^task__/, '').replace(/\.md$/, '')
+}
+
+export async function listTaskFiles(): Promise<string[]> {
+  const files = await readdir(TASKS_DIR)
+  return files
+    .filter(f => f.startsWith('task__') && f.endsWith('.md'))
+    .map(f => join(TASKS_DIR, f))
+}
+
+export async function loadTaskFromFile(filePath: string): Promise<ObsidianTask | null> {
+  try {
+    const content = await readFile(filePath, 'utf-8')
+    const fm = parseFrontmatter(content)
+    
+    // Extract body as description (first paragraph after frontmatter)
+    const bodyMatch = content.match(/^---\n[\s\S]*?\n---\n\n?(.*)$/)
+    const description = bodyMatch ? bodyMatch[1].trim() : ''
+    
+    // Parse status from frontmatter
+    let status: 'pending' | 'in-progress' | 'done' = 'pending'
+    const statusStr = fm.status?.toLowerCase()
+    if (statusStr === 'in-progress' || statusStr === 'inprogress') status = 'in-progress'
+    else if (statusStr === 'done' || statusStr === 'completed') status = 'done'
+    
+    // Parse tags from frontmatter
+    const tagsStr = fm.tags || '[]'
+    let tags: string[] = []
+    try {
+      tags = JSON.parse(tagsStr)
+    } catch {
+      if (fm.tags) tags = fm.tags.split(',').map(t => t.trim())
+    }
+    
+    return {
+      id: fm.id || basename(filePath).replace(/\.md$/, ''),
+      title: fm.title || basename(filePath, '.md'),
+      description: description.slice(0, 200),
+      status,
+      priority: parseInt(fm.priority) || 3,
+      owner: fm.owner || null,
+      assignee: fm.assignee || null,
+      project: fm.project || null,
+      tags,
+      createdAt: fm.created_at || null,
+      updatedAt: fm.updated_at || null,
+      source: fm.source || null,
+      filePath,
+    }
+  } catch (err) {
+    console.error(`Failed to load task from ${filePath}:`, err)
+    return null
+  }
+}
+
+export async function loadAllTasks(): Promise<ObsidianTask[]> {
+  const files = await listTaskFiles()
+  const tasks: ObsidianTask[] = []
+  
+  for (const file of files) {
+    const task = await loadTaskFromFile(file)
+    if (task) tasks.push(task)
+  }
+  
+  return tasks
+}
+
+export async function getBoardByProject(projectSlug?: string): Promise<BoardColumn[]> {
+  const allTasks = await loadAllTasks()
+  
+  // Filter by project if specified
+  const filtered = projectSlug 
+    ? allTasks.filter(t => t.project === projectSlug)
+    : allTasks
+  
+  return [
+    { name: 'To Do', status: 'pending', tasks: filtered.filter(t => t.status === 'pending') },
+    { name: 'In Progress', status: 'in-progress', tasks: filtered.filter(t => t.status === 'in-progress') },
+    { name: 'Done', status: 'done', tasks: filtered.filter(t => t.status === 'done') },
+  ]
+}
+
+export async function findTaskById(taskId: string): Promise<ObsidianTask | null> {
+  const files = await listTaskFiles()
+  const targetFile = files.find(f => f.includes(taskId) || f.includes(taskId.replace(/-/g, '')))
+  
+  if (!targetFile) return null
+  return loadTaskFromFile(targetFile)
+}
+
+export interface UpdateTaskResult {
+  ok: boolean
+  message: string
+  task?: ObsidianTask
+}
+
+export async function updateTaskStatus(taskId: string, newStatus: string, message?: string): Promise<UpdateTaskResult> {
+  const task = await findTaskById(taskId)
+  if (!task) {
+    return { ok: false, message: `Task not found: ${taskId}` }
+  }
+  
+  // Map status
+  let status = 'pending'
+  if (newStatus === 'in-progress' || newStatus === 'inprogress') status = 'in-progress'
+  else if (newStatus === 'done' || newStatus === 'completed') status = 'done'
+  else if (newStatus === 'pending') status = 'pending'
+  else return { ok: false, message: `Invalid status: ${newStatus}` }
+  
+  try {
+    let content = await readFile(task.filePath, 'utf-8')
+    const now = new Date().toISOString()
+    
+    // Update frontmatter status
+    content = content.replace(/^status:.*$/m, `status: ${status}`)
+    content = content.replace(/^updated_at:.*$/m, `updated_at: ${now}`)
+    
+    // Add log entry if message provided
+    if (message) {
+      content = content.replace(
+        /^## progress log$/m,
+        `## progress log\n- ${now} ${message}`
+      )
+    }
+    
+    await writeFile(task.filePath, content, 'utf-8')
+    
+    return { 
+      ok: true, 
+      message: `Updated task ${taskId} status to ${status}`,
+      task: await loadTaskFromFile(task.filePath) || undefined
+    }
+  } catch (err) {
+    return { ok: false, message: `Failed to update: ${err}` }
+  }
+}
+
+export async function createTask(options: {
+  title: string
+  description?: string
+  project?: string
+  priority?: number
+  owner?: string
+  assignee?: string
+  tags?: string[]
+}): Promise<UpdateTaskResult> {
+  const id = `task__${options.title.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '')}_${Date.now().toString(36)}`
+  const now = new Date().toISOString()
+  
+  const frontmatter = `---
+id: ${id}
+type: task
+status: pending
+owner: ${options.owner || 'oracle'}
+assignee: ${options.assignee || ''}
+project: ${options.project || ''}
+priority: ${options.priority || 3}
+source: cli:board:create
+created_at: ${now}
+updated_at: ${now}
+tags: ${JSON.stringify(options.tags || [])}
+---
+
+# ${options.title}
+
+${options.description || ''}
+`.trim()
+  
+  const filePath = join(TASKS_DIR, `${id}.md`)
+  
+  try {
+    await writeFile(filePath, frontmatter, 'utf-8')
+    return { 
+      ok: true, 
+      message: `Created task: ${options.title}`,
+      task: await loadTaskFromFile(filePath) || undefined
+    }
+  } catch (err) {
+    return { ok: false, message: `Failed to create task: ${err}` }
+  }
+}