@objectstack/cli 4.0.1 → 4.0.3

package/src/commands/serve.ts

@@ -263,6 +263,22 @@ export default class Serve extends Command {
         }
       }
 
+      // 5. Auto-register SetupPlugin BEFORE config plugins so that other
+      // plugins (e.g. AuthPlugin) can call setupNav.contribute() during init.
+      const hasSetupPlugin = plugins.some(
+        (p: any) => p.name === 'com.objectstack.setup' || p.constructor?.name === 'SetupPlugin'
+      );
+      if (!hasSetupPlugin) {
+        try {
+          const setupPkg = '@objectstack/plugin-setup';
+          const { SetupPlugin } = await import(/* webpackIgnore: true */ setupPkg);
+          await kernel.use(new SetupPlugin());
+          trackPlugin('Setup');
+        } catch {
+          // @objectstack/plugin-setup not installed — setup app unavailable
+        }
+      }
+
       if (plugins.length > 0) {
         for (const plugin of plugins) {
           try {
@@ -318,6 +334,28 @@ export default class Serve extends Command {
         }
       }
 
+      // 4. Auto-register AIServicePlugin if not already loaded by config plugins.
+      // Registered AFTER Dispatcher so that the ai:routes hook listener is
+      // already in place when AIServicePlugin.start() fires the hook.
+      const hasAIPlugin = plugins.some(
+        (p: any) => p.name === 'com.objectstack.service-ai'
+            || p.constructor?.name === 'AIServicePlugin'
+      );
+      if (!hasAIPlugin) {
+        try {
+          const aiPkg = '@objectstack/service-ai';
+          const { AIServicePlugin } = await import(/* webpackIgnore: true */ aiPkg);
+
+          // AIServicePlugin will auto-detect LLM provider from environment variables
+          // (AI_GATEWAY_MODEL, OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY)
+          // No need to manually construct the adapter here.
+          await kernel.use(new AIServicePlugin());
+          trackPlugin('AIService');
+        } catch {
+          // @objectstack/service-ai not installed — AI features unavailable
+        }
+      }
+
       // ── Studio UI ─────────────────────────────────────────────────
       // In dev mode, Studio UI is enabled by default (use --no-ui to disable).
       // Always serves the pre-built dist/ — no Vite dev server, no extra port.

package/src/utils/api-client.ts

@@ -0,0 +1,88 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { ObjectStackClient } from '@objectstack/client';
+import { readAuthConfig } from './auth-config.js';
+
+/**
+ * API client configuration options for CLI commands
+ */
+export interface ApiClientOptions {
+  /**
+   * Server URL (defaults to OBJECTSTACK_URL env var or http://localhost:3000)
+   */
+  url?: string;
+  /**
+   * Authentication token (defaults to stored credentials or OBJECTSTACK_TOKEN env var)
+   */
+  token?: string;
+  /**
+   * Enable debug logging
+   */
+  debug?: boolean;
+}
+
+/**
+ * Result returned by createApiClient — exposes the resolved token so commands
+ * can call requireAuth() without accessing private client fields.
+ */
+export interface ApiClientResult {
+  client: ObjectStackClient;
+  token?: string;
+}
+
+/**
+ * Create an authenticated ObjectStack API client for CLI commands.
+ *
+ * Resolves configuration in this priority order:
+ * 1. Explicit options passed to the function
+ * 2. Environment variables (OBJECTSTACK_URL, OBJECTSTACK_TOKEN)
+ * 3. Stored credentials from `os auth login`
+ * 4. Defaults (http://localhost:3000)
+ */
+export async function createApiClient(options: ApiClientOptions = {}): Promise<ApiClientResult> {
+  // Resolve server URL (without applying defaults yet)
+  let baseUrl = options.url || process.env.OBJECTSTACK_URL;
+
+  // Resolve authentication token
+  let token = options.token || process.env.OBJECTSTACK_TOKEN;
+
+  // If URL or token is missing, try to load from stored credentials
+  if (!baseUrl || !token) {
+    try {
+      const authConfig = await readAuthConfig();
+      if (!token && authConfig.token) {
+        token = authConfig.token;
+      }
+      if (!baseUrl && authConfig.url) {
+        baseUrl = authConfig.url;
+      }
+    } catch {
+      // No stored credentials - commands will fail if auth is required
+    }
+  }
+
+  // Apply final default for baseUrl if still not resolved
+  if (!baseUrl) {
+    baseUrl = 'http://localhost:3000';
+  }
+
+  const client = new ObjectStackClient({
+    baseUrl,
+    token,
+    debug: options.debug || false,
+  });
+
+  return { client, token };
+}
+
+/**
+ * Ensure authentication is present, throwing an error if not.
+ * Use this in commands that require authentication.
+ */
+export function requireAuth(token?: string): void {
+  if (!token) {
+    throw new Error(
+      'Authentication required. Please run `os auth login` or set OBJECTSTACK_TOKEN environment variable.'
+    );
+  }
+}

package/src/utils/auth-config.ts

@@ -0,0 +1,107 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readFile, writeFile, mkdir, chmod } from 'node:fs/promises';
+
+/**
+ * Authentication configuration stored in ~/.objectstack/credentials.json
+ */
+export interface AuthConfig {
+  /**
+   * Server URL (base URL for the ObjectStack instance)
+   */
+  url: string;
+  /**
+   * Authentication token (Bearer token)
+   */
+  token: string;
+  /**
+   * User email (for display purposes)
+   */
+  email?: string;
+  /**
+   * User ID
+   */
+  userId?: string;
+  /**
+   * Timestamp when credentials were created
+   */
+  createdAt: string;
+  /**
+   * Timestamp when credentials were last used
+   */
+  lastUsedAt?: string;
+}
+
+/**
+ * Get the path to the credentials file
+ */
+export function getCredentialsPath(): string {
+  return join(homedir(), '.objectstack', 'credentials.json');
+}
+
+/**
+ * Read stored authentication configuration
+ */
+export async function readAuthConfig(): Promise<AuthConfig> {
+  const path = getCredentialsPath();
+  try {
+    const content = await readFile(path, 'utf-8');
+    return JSON.parse(content) as AuthConfig;
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      throw new Error('No stored credentials found. Please run `os auth login` first.');
+    }
+    throw new Error(`Failed to read credentials: ${error.message}`);
+  }
+}
+
+/**
+ * Write authentication configuration
+ */
+export async function writeAuthConfig(config: AuthConfig): Promise<void> {
+  const path = getCredentialsPath();
+  const dir = join(homedir(), '.objectstack');
+
+  // Ensure directory exists
+  await mkdir(dir, { recursive: true });
+
+  // Write credentials file
+  await writeFile(path, JSON.stringify(config, null, 2), { mode: 0o600 });
+
+  // Explicitly enforce permissions in case the file already existed with broader perms
+  try {
+    await chmod(path, 0o600);
+  } catch {
+    // Best-effort — platforms that don't support chmod will silently continue
+  }
+}
+
+/**
+ * Delete stored authentication configuration
+ */
+export async function deleteAuthConfig(): Promise<void> {
+  const path = getCredentialsPath();
+  try {
+    const { unlink } = await import('node:fs/promises');
+    await unlink(path);
+  } catch (error: any) {
+    if (error.code !== 'ENOENT') {
+      throw new Error(`Failed to delete credentials: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Update last used timestamp
+ */
+export async function touchAuthConfig(): Promise<void> {
+  try {
+    const config = await readAuthConfig();
+    config.lastUsedAt = new Date().toISOString();
+    await writeAuthConfig(config);
+  } catch {
+    // Ignore errors - this is best-effort
+  }
+}

package/src/utils/output-formatter.ts

@@ -0,0 +1,91 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import chalk from 'chalk';
+import yaml from 'yaml';
+
+/**
+ * Output format options for CLI commands
+ */
+export type OutputFormat = 'json' | 'table' | 'yaml';
+
+/**
+ * Format and output data according to the specified format
+ */
+export function formatOutput(data: any, format: OutputFormat = 'json'): void {
+  switch (format) {
+    case 'json':
+      console.log(JSON.stringify(data, null, 2));
+      break;
+
+    case 'yaml':
+      console.log(yaml.stringify(data));
+      break;
+
+    case 'table':
+      // For table format, handle different data structures
+      if (Array.isArray(data)) {
+        printTable(data);
+      } else if (data && typeof data === 'object') {
+        // For single objects, print as key-value pairs
+        printKeyValue(data);
+      } else {
+        console.log(String(data));
+      }
+      break;
+
+    default:
+      console.log(JSON.stringify(data, null, 2));
+  }
+}
+
+/**
+ * Print data as a table (for arrays of objects)
+ */
+function printTable(data: any[]): void {
+  if (data.length === 0) {
+    console.log(chalk.dim('(no data)'));
+    return;
+  }
+
+  // Get all unique keys from all objects
+  const keys = Array.from(
+    new Set(data.flatMap(item => Object.keys(item)))
+  );
+
+  // Print header
+  console.log(chalk.bold(keys.join(' | ')));
+  console.log(chalk.dim('─'.repeat(keys.join(' | ').length)));
+
+  // Print rows
+  for (const item of data) {
+    const values = keys.map(key => {
+      const value = item[key];
+      if (value === null || value === undefined) return chalk.dim('-');
+      if (typeof value === 'object') return chalk.dim('[object]');
+      return String(value);
+    });
+    console.log(values.join(' | '));
+  }
+
+  console.log(chalk.dim(`\n${data.length} row(s)`));
+}
+
+/**
+ * Print object as key-value pairs
+ */
+function printKeyValue(data: Record<string, any>, indent = 0): void {
+  const prefix = '  '.repeat(indent);
+
+  for (const [key, value] of Object.entries(data)) {
+    if (value === null || value === undefined) {
+      console.log(`${prefix}${chalk.dim(key + ':')} ${chalk.dim('null')}`);
+    } else if (typeof value === 'object' && !Array.isArray(value)) {
+      console.log(`${prefix}${chalk.bold(key + ':')}`);
+      printKeyValue(value, indent + 1);
+    } else if (Array.isArray(value)) {
+      console.log(`${prefix}${chalk.dim(key + ':')} ${chalk.dim(`[${value.length} items]`)}`);
+    } else {
+      console.log(`${prefix}${chalk.dim(key + ':')} ${chalk.white(String(value))}`);
+    }
+  }
+}

package/test/remote-api-commands.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from 'vitest';
+import AuthLogin from '../src/commands/auth/login';
+import AuthLogout from '../src/commands/auth/logout';
+import AuthWhoami from '../src/commands/auth/whoami';
+import DataQuery from '../src/commands/data/query';
+import DataGet from '../src/commands/data/get';
+import DataCreate from '../src/commands/data/create';
+import DataUpdate from '../src/commands/data/update';
+import DataDelete from '../src/commands/data/delete';
+import MetaList from '../src/commands/meta/list';
+import MetaGet from '../src/commands/meta/get';
+import MetaRegister from '../src/commands/meta/register';
+import MetaDelete from '../src/commands/meta/delete';
+
+describe('Remote API Commands (oclif)', () => {
+  describe('Auth Commands', () => {
+    it('should have auth login command', () => {
+      expect(AuthLogin.description).toContain('Authenticate');
+      expect(AuthLogin.flags).toHaveProperty('url');
+      expect(AuthLogin.flags).toHaveProperty('email');
+      expect(AuthLogin.flags).toHaveProperty('password');
+      expect(AuthLogin.flags).toHaveProperty('json');
+    });
+
+    it('should have auth logout command', () => {
+      expect(AuthLogout.description).toContain('Clear');
+      expect(AuthLogout.flags).toHaveProperty('json');
+    });
+
+    it('should have auth whoami command', () => {
+      expect(AuthWhoami.description).toContain('session');
+      expect(AuthWhoami.flags).toHaveProperty('url');
+      expect(AuthWhoami.flags).toHaveProperty('token');
+      expect(AuthWhoami.flags).toHaveProperty('format');
+    });
+
+    it('auth commands should have examples', () => {
+      expect(AuthLogin.examples).toBeDefined();
+      expect(AuthLogin.examples.length).toBeGreaterThan(0);
+      expect(AuthLogout.examples).toBeDefined();
+      expect(AuthWhoami.examples).toBeDefined();
+    });
+  });
+
+  describe('Data Commands', () => {
+    it('should have data query command', () => {
+      expect(DataQuery.description).toContain('Query');
+      expect(DataQuery.args).toHaveProperty('object');
+      expect(DataQuery.flags).toHaveProperty('filter');
+      expect(DataQuery.flags).toHaveProperty('fields');
+      expect(DataQuery.flags).toHaveProperty('sort');
+      expect(DataQuery.flags).toHaveProperty('limit');
+      expect(DataQuery.flags).toHaveProperty('offset');
+      expect(DataQuery.flags).toHaveProperty('format');
+    });
+
+    it('should have data get command', () => {
+      expect(DataGet.description).toContain('single record');
+      expect(DataGet.args).toHaveProperty('object');
+      expect(DataGet.args).toHaveProperty('id');
+      expect(DataGet.flags).toHaveProperty('format');
+    });
+
+    it('should have data create command', () => {
+      expect(DataCreate.description).toContain('Create');
+      expect(DataCreate.args).toHaveProperty('object');
+      expect(DataCreate.flags).toHaveProperty('data');
+      expect(DataCreate.flags).toHaveProperty('format');
+    });
+
+    it('should have data update command', () => {
+      expect(DataUpdate.description).toContain('Update');
+      expect(DataUpdate.args).toHaveProperty('object');
+      expect(DataUpdate.args).toHaveProperty('id');
+      expect(DataUpdate.flags).toHaveProperty('data');
+      expect(DataUpdate.flags).toHaveProperty('format');
+    });
+
+    it('should have data delete command', () => {
+      expect(DataDelete.description).toContain('Delete');
+      expect(DataDelete.args).toHaveProperty('object');
+      expect(DataDelete.args).toHaveProperty('id');
+      expect(DataDelete.flags).toHaveProperty('format');
+    });
+
+    it('data commands should support common flags', () => {
+      const commands = [DataQuery, DataGet, DataCreate, DataUpdate, DataDelete];
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('url');
+        expect(cmd.flags).toHaveProperty('token');
+      });
+    });
+
+    it('data commands should have examples', () => {
+      expect(DataQuery.examples).toBeDefined();
+      expect(DataQuery.examples.length).toBeGreaterThan(0);
+      expect(DataGet.examples).toBeDefined();
+      expect(DataCreate.examples).toBeDefined();
+      expect(DataUpdate.examples).toBeDefined();
+      expect(DataDelete.examples).toBeDefined();
+    });
+  });
+
+  describe('Metadata Commands', () => {
+    it('should have meta list command', () => {
+      expect(MetaList.description).toContain('List metadata');
+      expect(MetaList.args).toHaveProperty('type');
+      expect(MetaList.flags).toHaveProperty('format');
+    });
+
+    it('should have meta get command', () => {
+      expect(MetaGet.description).toContain('Get');
+      expect(MetaGet.args).toHaveProperty('type');
+      expect(MetaGet.args).toHaveProperty('name');
+      expect(MetaGet.flags).toHaveProperty('format');
+    });
+
+    it('should have meta register command', () => {
+      expect(MetaRegister.description).toContain('Register');
+      expect(MetaRegister.args).toHaveProperty('type');
+      expect(MetaRegister.flags).toHaveProperty('data');
+      expect(MetaRegister.flags).toHaveProperty('format');
+    });
+
+    it('should have meta delete command', () => {
+      expect(MetaDelete.description).toContain('Delete');
+      expect(MetaDelete.args).toHaveProperty('type');
+      expect(MetaDelete.args).toHaveProperty('name');
+      expect(MetaDelete.flags).toHaveProperty('format');
+    });
+
+    it('meta commands should support common flags', () => {
+      const commands = [MetaList, MetaGet, MetaRegister, MetaDelete];
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('url');
+        expect(cmd.flags).toHaveProperty('token');
+      });
+    });
+
+    it('meta commands should have examples', () => {
+      expect(MetaList.examples).toBeDefined();
+      expect(MetaList.examples.length).toBeGreaterThan(0);
+      expect(MetaGet.examples).toBeDefined();
+      expect(MetaRegister.examples).toBeDefined();
+      expect(MetaDelete.examples).toBeDefined();
+    });
+  });
+
+  describe('Command Conventions', () => {
+    it('all remote commands should support --url flag with OBJECTSTACK_URL env var', () => {
+      const commands = [
+        AuthLogin, AuthWhoami,
+        DataQuery, DataGet, DataCreate, DataUpdate, DataDelete,
+        MetaList, MetaGet, MetaRegister, MetaDelete
+      ];
+
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('url');
+        expect(cmd.flags.url).toHaveProperty('env', 'OBJECTSTACK_URL');
+      });
+    });
+
+    it('authenticated commands should support --token flag with OBJECTSTACK_TOKEN env var', () => {
+      const commands = [
+        AuthWhoami,
+        DataQuery, DataGet, DataCreate, DataUpdate, DataDelete,
+        MetaList, MetaGet, MetaRegister, MetaDelete
+      ];
+
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('token');
+        expect(cmd.flags.token).toHaveProperty('env', 'OBJECTSTACK_TOKEN');
+      });
+    });
+
+    it('all commands should support output formatting', () => {
+      const commands = [
+        AuthWhoami,
+        DataQuery, DataGet, DataCreate, DataUpdate, DataDelete,
+        MetaList, MetaGet, MetaRegister, MetaDelete
+      ];
+
+      commands.forEach(cmd => {
+        expect(cmd.flags).toHaveProperty('format');
+      });
+    });
+  });
+});