optimal-cli 1.0.1 → 1.1.0

package/tests/config-command-smoke.test.ts

@@ -0,0 +1,395 @@
+/**
+ * Command-level smoke tests for optimal config commands.
+ * These test the CLI surface directly via subprocess invocation.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile, readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { spawn } from 'node:child_process'
+import { env } from 'node:process'
+
+// Run from the actual project directory, but with a custom HOME for config isolation
+const PROJECT_DIR = '/home/oracle/.openclaw/workspace/optimal-cli'
+
+function runOptimalCli(args: string[], extraEnv: Record<string, string> = {}): Promise<{ stdout: string; stderr: string; code: number }> {
+  return new Promise((resolve) => {
+    const child = spawn('npx', ['tsx', 'bin/optimal.ts', ...args], {
+      cwd: PROJECT_DIR,
+      env: { ...env, ...extraEnv },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout?.on('data', (data) => { stdout += data.toString() })
+    child.stderr?.on('data', (data) => { stderr += data.toString() })
+    child.on('close', (code) => {
+      resolve({ stdout, stderr, code: code ?? 0 })
+    })
+  })
+}
+
+test('config init creates local config file with defaults', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    const result = await runOptimalCli(
+      ['config', 'init', '--owner', 'test-smoke', '--profile', 'testprof', '--brand', 'CRE-11TRUST', '--timezone', 'America/New_York'],
+      { OPTIMAL_CONFIG_DIR: configDir, OPTIMAL_CONFIG_OWNER: 'test-smoke' }
+    )
+
+    assert.equal(result.code, 0, `config init failed: ${result.stderr}`)
+    assert.match(result.stdout, /Initialized config/)
+
+    // Verify config file was created
+    const configPath = join(configDir, 'optimal.config.json')
+    const content = await readFile(configPath, 'utf-8')
+    const config = JSON.parse(content)
+
+    assert.equal(config.version, '1.0.0')
+    assert.equal(config.profile.name, 'testprof')
+    assert.equal(config.profile.owner, 'test-smoke')
+    assert.equal(config.defaults.brand, 'CRE-11TRUST')
+    assert.equal(config.defaults.timezone, 'America/New_York')
+
+    // Verify history was created
+    const historyPath = join(configDir, 'config-history.log')
+    const history = await readFile(historyPath, 'utf-8')
+    assert.match(history, /init profile=testprof/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config doctor reports health for existing config', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    // First create a config
+    await runOptimalCli(
+      ['config', 'init', '--owner', 'test-doctor', '--profile', 'default', '--brand', 'LIFEINSUR', '--timezone', 'America/Los_Angeles'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    // Now run doctor
+    const result = await runOptimalCli(
+      ['config', 'doctor'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 0, `config doctor failed: ${result.stderr}`)
+    assert.match(result.stdout, /config: ok/)
+    assert.match(result.stdout, /profile: default/)
+    assert.match(result.stdout, /owner: test-doctor/)
+    assert.match(result.stdout, /version: 1.0.0/)
+    assert.match(result.stdout, /hash:/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config export writes JSON to specified path', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    // First create a config
+    await runOptimalCli(
+      ['config', 'init', '--owner', 'test-export', '--profile', 'default'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    // Export to a temp path
+    const exportPath = join(configDir, 'exported-config.json')
+    const result = await runOptimalCli(
+      ['config', 'export', '--out', exportPath],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 0, `config export failed: ${result.stderr}`)
+    assert.match(result.stdout, /Exported config/)
+
+    // Verify exported file
+    const content = await readFile(exportPath, 'utf-8')
+    const config = JSON.parse(content)
+    assert.equal(config.profile.owner, 'test-export')
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config import reads JSON from specified path', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    // Create a config file to import
+    const importPath = join(configDir, 'import-config.json')
+    const configToImport = {
+      version: '1.0.0',
+      profile: { name: 'imported', owner: 'test-import', updated_at: '2026-03-06T15:00:00.000Z' },
+      providers: { supabase: { project_ref: 'test', url: 'https://test.supabase.co', anon_key_present: true }, strapi: { base_url: 'https://test.strapi.com', token_present: true } },
+      defaults: { brand: 'CRE-11TRUST', timezone: 'America/Chicago' },
+      features: { cms: true, tasks: false, deploy: false },
+    }
+    await writeFile(importPath, JSON.stringify(configToImport, null, 2))
+
+    // Import it
+    const result = await runOptimalCli(
+      ['config', 'import', '--in', importPath],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 0, `config import failed: ${result.stderr}`)
+    assert.match(result.stdout, /Imported config/)
+
+    // Verify it was imported
+    const configPath = join(configDir, 'optimal.config.json')
+    const content = await readFile(configPath, 'utf-8')
+    const config = JSON.parse(content)
+    assert.equal(config.profile.name, 'imported')
+    assert.equal(config.profile.owner, 'test-import')
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config sync pull --dry-run shows what would be pulled', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    // Create a config first
+    await runOptimalCli(
+      ['config', 'init', '--owner', 'test-pull', '--profile', 'default'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    // Run dry-run pull
+    const result = await runOptimalCli(
+      ['config', 'sync', 'pull', '--profile', 'default', '--dry-run'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 0, `config sync pull --dry-run failed: ${result.stderr}`)
+    assert.match(result.stdout, /\[dry-run\]/)
+    assert.match(result.stdout, /Would pull profile/)
+    assert.match(result.stdout, /test-pull/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config sync push --dry-run shows what would be pushed', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    // Create a config first
+    await runOptimalCli(
+      ['config', 'init', '--owner', 'test-push', '--profile', 'default'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    // Run dry-run push
+    const result = await runOptimalCli(
+      ['config', 'sync', 'push', '--agent', 'test-push-agent', '--profile', 'default', '--dry-run'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 0, `config sync push --dry-run failed: ${result.stderr}`)
+    assert.match(result.stdout, /\[dry-run\]/)
+    assert.match(result.stdout, /Would push/)
+    assert.match(result.stdout, /test-push-agent/)
+    assert.match(result.stdout, /hash:/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config sync push --force --dry-run shows force flag', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    // Create a config first
+    await runOptimalCli(
+      ['config', 'init', '--owner', 'test-force', '--profile', 'default'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    // Run dry-run push with force
+    const result = await runOptimalCli(
+      ['config', 'sync', 'push', '--agent', 'test-force-agent', '--profile', 'default', '--force', '--dry-run'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 0, `config sync push --force --dry-run failed: ${result.stderr}`)
+    assert.match(result.stdout, /Force: true/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+// Error case tests
+
+test('config doctor fails gracefully when no config exists', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    const result = await runOptimalCli(
+      ['config', 'doctor'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 1, `Expected failure code, got: ${result.code}`)
+    // Error message goes to stdout (console.log), not stderr
+    assert.match(result.stdout, /No local config found/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config export fails when no config exists', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    const result = await runOptimalCli(
+      ['config', 'export', '--out', join(configDir, 'out.json')],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 1, `Expected failure code, got: ${result.code}`)
+    assert.match(result.stderr, /No local config found/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config sync push --dry-run fails when no config exists', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    const result = await runOptimalCli(
+      ['config', 'sync', 'push', '--agent', 'test', '--dry-run'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 1, `Expected failure code, got: ${result.code}`)
+    assert.match(result.stderr, /No local config/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config import fails when input file does not exist', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    const result = await runOptimalCli(
+      ['config', 'import', '--in', '/nonexistent/path/config.json'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 1, `Expected failure code, got: ${result.code}`)
+    assert.match(result.stderr, /Input file not found/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config sync pull fails gracefully without supabase config', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    // Create a config first
+    await runOptimalCli(
+      ['config', 'init', '--owner', 'test-nosupabase', '--profile', 'default'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    // Try sync pull without supabase env vars - should fail gracefully
+    const result = await runOptimalCli(
+      ['config', 'sync', 'pull', '--profile', 'default'],
+      { 
+        OPTIMAL_CONFIG_DIR: configDir,
+        OPTIMAL_SUPABASE_URL: '',  // empty = not configured
+        OPTIMAL_SUPABASE_ANON_KEY: ''
+      }
+    )
+
+    assert.equal(result.code, 1, `Expected failure code, got: ${result.code}`)
+    // Should mention missing env vars
+    assert.ok(result.stdout.includes('Missing env vars') || result.stderr.includes('Missing env vars'), 
+      `Expected missing env vars error, got: ${result.stdout} ${result.stderr}`)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config init --force overwrites existing config', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    // Create initial config
+    await runOptimalCli(
+      ['config', 'init', '--owner', 'initial-owner', '--profile', 'default', '--brand', 'CRE-11TRUST'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    // Verify initial config
+    let configPath = join(configDir, 'optimal.config.json')
+    let content = await readFile(configPath, 'utf-8')
+    let config = JSON.parse(content)
+    assert.equal(config.profile.owner, 'initial-owner')
+
+    // Now init again with --force
+    const result = await runOptimalCli(
+      ['config', 'init', '--owner', 'new-owner', '--profile', 'default', '--brand', 'LIFEINSUR', '--force'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 0, `config init --force failed: ${result.stderr}`)
+    assert.match(result.stdout, /Initialized config/)
+
+    // Verify it was overwritten
+    content = await readFile(configPath, 'utf-8')
+    config = JSON.parse(content)
+    assert.equal(config.profile.owner, 'new-owner')
+    assert.equal(config.defaults.brand, 'LIFEINSUR')
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+test('config init without --force fails when config exists', async () => {
+  const configDir = await mkdtemp(join(tmpdir(), 'optimal-cli-smoke-'))
+  try {
+    // Create initial config
+    await runOptimalCli(
+      ['config', 'init', '--owner', 'first-owner', '--profile', 'default'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    // Try to init again without --force - should fail
+    const result = await runOptimalCli(
+      ['config', 'init', '--owner', 'second-owner', '--profile', 'default'],
+      { OPTIMAL_CONFIG_DIR: configDir }
+    )
+
+    assert.equal(result.code, 1, `Expected failure code, got: ${result.code}`)
+    assert.match(result.stderr, /Config already exists/)
+  } finally {
+    await rm(configDir, { recursive: true, force: true })
+  }
+})
+
+// Basic CLI smoke tests
+
+test('--version shows version number', async () => {
+  const result = await runOptimalCli(['--version'], {})
+  assert.equal(result.code, 0, `--version should succeed`)
+  assert.match(result.stdout, /0\./)  // version like 0.1.0
+})
+
+test('--help shows help', async () => {
+  const result = await runOptimalCli(['--help'], {})
+  assert.equal(result.code, 0, `--help should succeed`)
+  assert.match(result.stdout, /Usage:/)
+  assert.match(result.stdout, /Commands:/)
+})
+
+test('config --help shows config subcommands', async () => {
+  const result = await runOptimalCli(['config', '--help'], {})
+  assert.equal(result.code, 0, `config --help should succeed`)
+  assert.match(result.stdout, /init/)
+  assert.match(result.stdout, /doctor/)
+  assert.match(result.stdout, /export/)
+  assert.match(result.stdout, /import/)
+  assert.match(result.stdout, /sync/)
+})

package/tests/config-registry.test.ts

@@ -0,0 +1,173 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+type RegistryModule = typeof import('../lib/config/registry.ts')
+
+function makeConfig(owner: string, updatedAt: string) {
+  return {
+    version: '1.0.0' as const,
+    profile: { name: 'default', owner, updated_at: updatedAt },
+    providers: {
+      supabase: { project_ref: 'proj', url: 'https://example.supabase.co', anon_key_present: true },
+      strapi: { base_url: 'https://strapi.example.com', token_present: true },
+    },
+    defaults: { brand: 'CRE-11TRUST', timezone: 'America/New_York' },
+    features: { cms: true, tasks: true, deploy: true },
+  }
+}
+
+async function loadRegistryWithHome(home: string): Promise<RegistryModule> {
+  process.env.HOME = home
+  return import(`../lib/config/registry.ts?home=${encodeURIComponent(home)}&ts=${Date.now()}`)
+}
+
+test('sync pull uses OPTIMAL_CONFIG_OWNER fallback when no local config exists', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'optimal-cli-test-'))
+  try {
+    process.env.OPTIMAL_CONFIG_OWNER = 'fallback-owner'
+    const registry = await loadRegistryWithHome(home)
+
+    const remoteConfig = makeConfig('fallback-owner', '2026-03-05T11:00:00.000Z')
+
+    const supabaseMock = {
+      from() {
+        return {
+          select() { return this },
+          eq() { return this },
+          async maybeSingle() {
+            return {
+              data: {
+                owner: 'fallback-owner',
+                profile: 'default',
+                config_version: '1.0.0',
+                payload: remoteConfig,
+                payload_hash: registry.hashConfig(remoteConfig),
+                updated_at: '2026-03-05T11:00:00.000Z',
+              },
+              error: null,
+            }
+          },
+        }
+      },
+    }
+
+    registry.setRegistrySupabaseProviderForTests(() => supabaseMock as any)
+    const result = await registry.pullRegistryProfile('default')
+
+    assert.equal(result.ok, true)
+    assert.match(result.message, /registry pull ok/)
+
+    const local = await registry.readLocalConfig()
+    assert.ok(local)
+    assert.equal(local?.profile.owner, 'fallback-owner')
+
+    registry.resetRegistrySupabaseProviderForTests()
+  } finally {
+    delete process.env.OPTIMAL_CONFIG_OWNER
+    await rm(home, { recursive: true, force: true })
+  }
+})
+
+test('sync push returns conflict when remote is newer and different', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'optimal-cli-test-'))
+  try {
+    const registry = await loadRegistryWithHome(home)
+
+    const localConfig = makeConfig('oracle', '2026-03-05T10:00:00.000Z')
+    await registry.writeLocalConfig(localConfig)
+
+    const remoteConfig = makeConfig('oracle', '2026-03-05T12:00:00.000Z')
+
+    const supabaseMock = {
+      from() {
+        return {
+          select() { return this },
+          eq() { return this },
+          async maybeSingle() {
+            return {
+              data: {
+                owner: 'oracle',
+                profile: 'default',
+                config_version: '1.0.0',
+                payload: remoteConfig,
+                payload_hash: registry.hashConfig(remoteConfig),
+                updated_at: '2026-03-05T12:00:00.000Z',
+              },
+              error: null,
+            }
+          },
+          async upsert() {
+            throw new Error('upsert should not be called on conflict')
+          },
+        }
+      },
+    }
+
+    registry.setRegistrySupabaseProviderForTests(() => supabaseMock as any)
+    const result = await registry.pushRegistryProfile('default', false)
+
+    assert.equal(result.ok, false)
+    assert.match(result.message, /registry push conflict/)
+
+    registry.resetRegistrySupabaseProviderForTests()
+  } finally {
+    await rm(home, { recursive: true, force: true })
+  }
+})
+
+test('sync push with --force upserts newer local config', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'optimal-cli-test-'))
+  try {
+    const registry = await loadRegistryWithHome(home)
+
+    const localConfig = makeConfig('oracle', '2026-03-05T13:00:00.000Z')
+    await registry.writeLocalConfig(localConfig)
+
+    const remoteConfig = makeConfig('oracle', '2026-03-05T12:00:00.000Z')
+
+    let upsertPayload: any = null
+
+    const supabaseMock = {
+      from() {
+        return {
+          select() { return this },
+          eq() { return this },
+          async maybeSingle() {
+            return {
+              data: {
+                owner: 'oracle',
+                profile: 'default',
+                config_version: '1.0.0',
+                payload: remoteConfig,
+                payload_hash: registry.hashConfig(remoteConfig),
+                updated_at: '2026-03-05T12:00:00.000Z',
+              },
+              error: null,
+            }
+          },
+          async upsert(payload: any) {
+            upsertPayload = payload
+            return { error: null }
+          },
+        }
+      },
+    }
+
+    registry.setRegistrySupabaseProviderForTests(() => supabaseMock as any)
+    const result = await registry.pushRegistryProfile('default', true)
+
+    assert.equal(result.ok, true)
+    assert.match(result.message, /registry push ok/)
+    assert.ok(upsertPayload)
+    assert.equal(upsertPayload.owner, 'oracle')
+    assert.equal(upsertPayload.profile, 'default')
+    assert.equal(upsertPayload.source, 'optimal-cli')
+
+    registry.resetRegistrySupabaseProviderForTests()
+  } finally {
+    await rm(home, { recursive: true, force: true })
+  }
+})

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "paths": {
+      "@lib/*": ["./lib/*"]
+    }
+  },
+  "include": ["lib/**/*.ts", "bin/**/*.ts"],
+  "exclude": ["node_modules", "dist", "apps"]
+}

package/agents/profiles.json

@@ -1,5 +0,0 @@
-[
-  { "id": "claude-alpha", "skills": ["*"], "maxConcurrent": 3, "status": "idle" },
-  { "id": "claude-beta", "skills": ["generate-social-posts", "generate-newsletter", "publish-social-posts", "publish-blog", "scrape-ads"], "maxConcurrent": 2, "status": "idle" },
-  { "id": "claude-gamma", "skills": ["ingest-transactions", "stamp-transactions", "project-budget", "audit-financials", "manage-scenarios"], "maxConcurrent": 2, "status": "idle" }
-]

package/dist/bin/optimal.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import 'dotenv/config';