optimal-cli 1.0.0 → 1.0.1

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

@@ -0,0 +1,31 @@
+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 declare function isOptimalConfigV1(value: unknown): value is OptimalConfigV1;
+export declare function assertOptimalConfigV1(value: unknown): OptimalConfigV1;

package/dist/lib/config/schema.js

@@ -0,0 +1,25 @@
+export function isOptimalConfigV1(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const v = value;
+    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) {
+    if (!isOptimalConfigV1(value)) {
+        throw new Error('Invalid optimal config payload (v1)');
+    }
+    return value;
+}

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/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Centralized error handling for the Optimal CLI.
+ *
+ * Provides a typed CliError class, a user-friendly formatter,
+ * and a wrapCommand helper for Commander action handlers.
+ */
+export type ErrorCode = 'MISSING_ENV' | 'NOT_FOUND' | 'SUPABASE_ERROR' | 'VALIDATION_ERROR' | 'AUTH_ERROR' | 'NETWORK_ERROR' | 'FILE_ERROR' | 'UNKNOWN';
+export declare class CliError extends Error {
+    code: ErrorCode;
+    suggestion?: string | undefined;
+    constructor(message: string, code: ErrorCode, suggestion?: string | undefined);
+}
+/**
+ * Format an error for CLI output, print it to stderr, and exit with code 1.
+ */
+export declare function handleError(err: unknown): never;
+/**
+ * Wrap a Commander action handler so any thrown error is routed through
+ * handleError, giving the user a consistent, friendly message instead of
+ * an unhandled-rejection stack trace.
+ *
+ * Usage:
+ *   .action(wrapCommand(async (opts) => { ... }))
+ */
+export declare function wrapCommand<A extends unknown[]>(fn: (...args: A) => Promise<void>): (...args: A) => Promise<void>;

package/dist/lib/errors.js

@@ -0,0 +1,91 @@
+/**
+ * Centralized error handling for the Optimal CLI.
+ *
+ * Provides a typed CliError class, a user-friendly formatter,
+ * and a wrapCommand helper for Commander action handlers.
+ */
+// ── CliError ─────────────────────────────────────────────────────────────────
+export class CliError extends Error {
+    code;
+    suggestion;
+    constructor(message, code, suggestion) {
+        super(message);
+        this.code = code;
+        this.suggestion = suggestion;
+        this.name = 'CliError';
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+const SUGGESTIONS = {
+    MISSING_ENV: 'Ensure the required environment variables are set in your .env file or shell.',
+    NOT_FOUND: 'Double-check the identifier (slug, ID, or name) and try again.',
+    SUPABASE_ERROR: 'Verify your Supabase URL and service key are correct and the database is reachable.',
+    VALIDATION_ERROR: 'Review the command options with --help.',
+    AUTH_ERROR: 'Check your API token or credentials and make sure they have not expired.',
+    NETWORK_ERROR: 'Check your internet connection and verify the remote service is available.',
+    FILE_ERROR: 'Verify the file path exists and you have read/write permissions.',
+};
+function classifyError(err) {
+    if (err instanceof CliError) {
+        return { code: err.code, message: err.message };
+    }
+    if (err instanceof Error) {
+        const msg = err.message;
+        // Supabase / fetch errors
+        if (msg.includes('PGRST') || msg.includes('supabase') || msg.includes('relation')) {
+            return { code: 'SUPABASE_ERROR', message: msg };
+        }
+        if (msg.includes('ENOENT') || msg.includes('no such file')) {
+            return { code: 'FILE_ERROR', message: msg };
+        }
+        if (msg.includes('ECONNREFUSED') || msg.includes('fetch failed') || msg.includes('ETIMEDOUT')) {
+            return { code: 'NETWORK_ERROR', message: msg };
+        }
+        if (msg.includes('OPTIMAL_SUPABASE_URL') ||
+            msg.includes('OPTIMAL_SUPABASE_SERVICE_KEY') ||
+            msg.includes('env')) {
+            return { code: 'MISSING_ENV', message: msg };
+        }
+        return { code: 'UNKNOWN', message: msg };
+    }
+    return { code: 'UNKNOWN', message: String(err) };
+}
+// ── handleError ──────────────────────────────────────────────────────────────
+/**
+ * Format an error for CLI output, print it to stderr, and exit with code 1.
+ */
+export function handleError(err) {
+    const { code, message } = classifyError(err);
+    const suggestion = err instanceof CliError && err.suggestion
+        ? err.suggestion
+        : SUGGESTIONS[code] ?? '';
+    const lines = [
+        '',
+        `  Error [${code}]: ${message}`,
+    ];
+    if (suggestion) {
+        lines.push(`  Suggestion: ${suggestion}`);
+    }
+    lines.push('');
+    process.stderr.write(lines.join('\n'));
+    process.exit(1);
+}
+// ── wrapCommand ──────────────────────────────────────────────────────────────
+/**
+ * Wrap a Commander action handler so any thrown error is routed through
+ * handleError, giving the user a consistent, friendly message instead of
+ * an unhandled-rejection stack trace.
+ *
+ * Usage:
+ *   .action(wrapCommand(async (opts) => { ... }))
+ */
+export function wrapCommand(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    };
+}

package/dist/lib/format.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Lightweight CLI output formatting — ANSI colors, tables, badges.
+ * Zero external dependencies. Respects NO_COLOR env var.
+ */
+type Color = 'red' | 'green' | 'yellow' | 'blue' | 'cyan' | 'gray' | 'bold' | 'dim';
+/**
+ * Wrap text in ANSI escape codes for the given color/style.
+ * Returns plain text when NO_COLOR env var is set.
+ */
+export declare function colorize(text: string, color: Color): string;
+/**
+ * Render a bordered ASCII table with auto-sized columns.
+ * Headers are rendered in bold.
+ */
+export declare function table(headers: string[], rows: string[][]): string;
+/** Return a colored status string (e.g. "done" in green). */
+export declare function statusBadge(status: string): string;
+/** Return a colored priority label (e.g. "P1" in red). */
+export declare function priorityBadge(p: number): string;
+/** Print a green success message with a check mark prefix. */
+export declare function success(msg: string): void;
+/** Print a red error message with an X prefix. */
+export declare function error(msg: string): void;
+/** Print a yellow warning message with a warning prefix. */
+export declare function warn(msg: string): void;
+/** Print a blue info message with an info prefix. */
+export declare function info(msg: string): void;
+export {};

package/dist/lib/format.js

@@ -0,0 +1,98 @@
+/**
+ * Lightweight CLI output formatting — ANSI colors, tables, badges.
+ * Zero external dependencies. Respects NO_COLOR env var.
+ */
+// ── ANSI escape codes ───────────────────────────────────────────────
+const CODES = {
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    cyan: [36, 39],
+    gray: [90, 39],
+    bold: [1, 22],
+    dim: [2, 22],
+};
+/**
+ * Wrap text in ANSI escape codes for the given color/style.
+ * Returns plain text when NO_COLOR env var is set.
+ */
+export function colorize(text, color) {
+    if (process.env.NO_COLOR !== undefined)
+        return text;
+    const [open, close] = CODES[color];
+    return `\x1b[${open}m${text}\x1b[${close}m`;
+}
+// ── Table rendering ─────────────────────────────────────────────────
+/** Strip ANSI escape sequences to measure visible string width. */
+function stripAnsi(s) {
+    return s.replace(/\x1b\[\d+m/g, '');
+}
+/**
+ * Render a bordered ASCII table with auto-sized columns.
+ * Headers are rendered in bold.
+ */
+export function table(headers, rows) {
+    // Compute column widths from headers and all rows
+    const colWidths = headers.map((h, i) => {
+        let max = stripAnsi(h).length;
+        for (const row of rows) {
+            const cell = row[i] ?? '';
+            const len = stripAnsi(cell).length;
+            if (len > max)
+                max = len;
+        }
+        return max;
+    });
+    function padCell(cell, width) {
+        const visible = stripAnsi(cell).length;
+        return cell + ' '.repeat(Math.max(0, width - visible));
+    }
+    const sep = '+-' + colWidths.map(w => '-'.repeat(w)).join('-+-') + '-+';
+    const headerRow = '| ' + headers.map((h, i) => padCell(colorize(h, 'bold'), colWidths[i])).join(' | ') + ' |';
+    const bodyRows = rows.map(row => '| ' + row.map((cell, i) => padCell(cell ?? '', colWidths[i])).join(' | ') + ' |');
+    return [sep, headerRow, sep, ...bodyRows, sep].join('\n');
+}
+// ── Status & priority badges ────────────────────────────────────────
+const STATUS_COLORS = {
+    done: 'green',
+    in_progress: 'blue',
+    blocked: 'red',
+    ready: 'cyan',
+    backlog: 'gray',
+    cancelled: 'dim',
+    review: 'yellow',
+};
+/** Return a colored status string (e.g. "done" in green). */
+export function statusBadge(status) {
+    const color = STATUS_COLORS[status] ?? 'dim';
+    return colorize(status, color);
+}
+const PRIORITY_COLORS = {
+    1: 'red',
+    2: 'yellow',
+    3: 'blue',
+    4: 'gray',
+};
+/** Return a colored priority label (e.g. "P1" in red). */
+export function priorityBadge(p) {
+    const color = PRIORITY_COLORS[p] ?? 'gray';
+    return colorize(`P${p}`, color);
+}
+// ── Logging helpers ─────────────────────────────────────────────────
+/** Print a green success message with a check mark prefix. */
+export function success(msg) {
+    console.log(`${colorize('\u2713', 'green')} ${msg}`);
+}
+/** Print a red error message with an X prefix. */
+export function error(msg) {
+    console.error(`${colorize('\u2717', 'red')} ${msg}`);
+}
+/** Print a yellow warning message with a warning prefix. */
+export function warn(msg) {
+    console.warn(`${colorize('\u26a0', 'yellow')} ${msg}`);
+}
+/** Print a blue info message with an info prefix. */
+export function info(msg) {
+    console.log(`${colorize('\u2139', 'blue')} ${msg}`);
+}

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>;