@porchestra/cli 1.0.0

package/src/core/api/client.ts

@@ -0,0 +1,133 @@
+import got from 'got';
+import { ConfigManager } from '../config/config-manager.js';
+import { NetworkError, AuthenticationError } from '../../utils/errors.js';
+import {
+  ProjectsBriefResponse,
+  AgentsListResponse,
+  AgentToolsResponse,
+  UserInfo,
+  CliConfigResponse,
+  ApiResponse,
+} from '../../types/index.js';
+
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 1000;
+
+interface RequestOptions {
+  method: 'GET' | 'POST' | 'DELETE';
+  headers?: Record<string, string>;
+}
+
+export class ApiClient {
+  private configManager: ConfigManager;
+
+  constructor(configManager: ConfigManager) {
+    this.configManager = configManager;
+  }
+
+  private async getBaseUrl(): Promise<string> {
+    const config = await this.configManager.get();
+    return config.api?.baseUrl || 'https://api.porchestra.io/v1';
+  }
+
+  private async getToken(): Promise<string | undefined> {
+    const config = await this.configManager.get();
+    return config.auth?.token;
+  }
+
+  private async requestWithRetry<T>(
+    url: string,
+    options: RequestOptions,
+    attempt = 1
+  ): Promise<T> {
+    try {
+      const token = await this.getToken();
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        ...(token && { Authorization: `Bearer ${token}` }),
+        ...(options.headers || {}),
+      };
+
+      const response = await got(url, {
+        method: options.method,
+        headers,
+        retry: { limit: 0 },
+      }).json<ApiResponse<T>>();
+
+      return response.data;
+    } catch (error: any) {
+      if (error.response?.statusCode === 401) {
+        throw new AuthenticationError('Authentication failed. Please login again.');
+      }
+
+      const isRetryable =
+        error.code === 'ECONNRESET' ||
+        error.code === 'ETIMEDOUT' ||
+        error.code === 'ENOTFOUND' ||
+        (error.response?.statusCode && error.response.statusCode >= 500);
+
+      if (isRetryable && attempt < MAX_RETRIES) {
+        await new Promise(resolve => setTimeout(resolve, RETRY_DELAY * attempt));
+        return this.requestWithRetry(url, options, attempt + 1);
+      }
+
+      throw new NetworkError(
+        `API request failed: ${error.message}`,
+        error.response?.statusCode,
+        isRetryable
+      );
+    }
+  }
+
+  async getProjectsBrief(): Promise<ProjectsBriefResponse> {
+    const baseUrl = await this.getBaseUrl();
+    return this.requestWithRetry<ProjectsBriefResponse>(
+      `${baseUrl}/projects/brief`,
+      { method: 'GET' }
+    );
+  }
+
+  async getProjectAgents(
+    projectId: string,
+    environment?: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT'
+  ): Promise<AgentsListResponse> {
+    const baseUrl = await this.getBaseUrl();
+    const query = environment ? `?environment=${environment}` : '';
+    return this.requestWithRetry<AgentsListResponse>(
+      `${baseUrl}/projects/${projectId}/agents${query}`,
+      { method: 'GET' }
+    );
+  }
+
+  async getAgentTools(
+    projectId: string,
+    agentId: string,
+    environment?: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT'
+  ): Promise<AgentToolsResponse> {
+    const baseUrl = await this.getBaseUrl();
+    const query = environment ? `?environment=${environment}` : '';
+    return this.requestWithRetry<AgentToolsResponse>(
+      `${baseUrl}/projects/${projectId}/agents/${agentId}/tools${query}`,
+      { method: 'GET' }
+    );
+  }
+
+  async getCurrentUser(token: string): Promise<UserInfo> {
+    const baseUrl = await this.getBaseUrl();
+    return this.requestWithRetry<UserInfo>(
+      `${baseUrl}/auth/me`,
+      {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${token}` },
+      }
+    );
+  }
+
+  async getCliConfig(): Promise<CliConfigResponse> {
+    const baseUrl = await this.getBaseUrl();
+    return this.requestWithRetry<CliConfigResponse>(
+      `${baseUrl}/cli/config`,
+      { method: 'GET' }
+    );
+  }
+}

package/src/core/auth/auth-service.ts

@@ -0,0 +1,176 @@
+import { ConfigManager } from '../config/config-manager.js';
+import { AuthenticationError, NetworkError } from '../../utils/errors.js';
+import {
+  ApiResponse,
+  CliTokenResponse,
+  CliTokenRefreshResponse,
+  CliTokenRevokeResponse,
+  UserInfo,
+} from '../../types/index.js';
+import got from 'got';
+import os from 'os';
+
+interface LoginCredentials {
+  email: string;
+  password: string;
+  apiUrl?: string;
+  deviceName?: string;
+  skipTlsVerify?: boolean;
+}
+
+export class AuthService {
+  private configManager: ConfigManager;
+
+  constructor(configManager: ConfigManager) {
+    this.configManager = configManager;
+  }
+
+  async login(credentials: LoginCredentials): Promise<CliTokenResponse> {
+    const config = await this.configManager.get();
+    const baseUrl = credentials.apiUrl || config.api?.baseUrl || 'https://api.porchestra.io/v1';
+    
+    const deviceInfo = {
+      os: os.platform(),
+      version: os.release(),
+      cliVersion: '1.0.0',
+    };
+
+    const deviceName = credentials.deviceName || `${os.hostname()} - ${deviceInfo.os}`;
+
+    try {
+      const response = await got.post(`${baseUrl}/cli/login`, {
+        json: {
+          email: credentials.email,
+          password: credentials.password,
+          deviceName,
+          deviceInfo,
+        },
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        https: {
+          rejectUnauthorized: !credentials.skipTlsVerify,
+        },
+      }).json<ApiResponse<CliTokenResponse>>();
+
+      return response.data;
+    } catch (error: any) {
+      if (error.response?.statusCode) {
+        if (error.response.statusCode === 401) {
+          throw new AuthenticationError('Invalid email or password');
+        }
+        throw new AuthenticationError(`Login failed: ${error.message}`);
+      }
+      if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND' || error.code === 'ETIMEDOUT') {
+        throw new NetworkError(`Network error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  async refreshToken(tokenId: string, currentToken: string): Promise<CliTokenRefreshResponse> {
+    const config = await this.configManager.get();
+    const baseUrl = config.api?.baseUrl || 'https://api.porchestra.io/v1';
+
+    try {
+      const response = await got.post(`${baseUrl}/cli/token/refresh`, {
+        json: {
+          tokenId,
+          currentToken,
+        },
+        headers: {
+          'Authorization': `Bearer ${currentToken}`,
+          'Content-Type': 'application/json',
+        },
+      }).json<ApiResponse<CliTokenRefreshResponse>>();
+
+      return response.data;
+    } catch (error: any) {
+      if (error.response?.statusCode === 401) {
+        throw new AuthenticationError('Token refresh failed. Please login again.');
+      }
+      throw error;
+    }
+  }
+
+  async revokeToken(token: string, revokeAll = false): Promise<CliTokenRevokeResponse> {
+    const config = await this.configManager.get();
+    const baseUrl = config.api?.baseUrl || 'https://api.porchestra.io/v1';
+
+    try {
+      const response = await got.delete(`${baseUrl}/cli/token`, {
+        json: {
+          revokeAll,
+        },
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+      }).json<ApiResponse<CliTokenRevokeResponse>>();
+
+      return response.data;
+    } catch (error: any) {
+      if (error.response?.statusCode === 401) {
+        throw new AuthenticationError('Token already revoked or invalid');
+      }
+      throw error;
+    }
+  }
+
+  async getCurrentUser(token: string): Promise<UserInfo> {
+    const config = await this.configManager.get();
+    const baseUrl = config.api?.baseUrl || 'https://api.porchestra.io/v1';
+
+    try {
+      const response = await got.get(`${baseUrl}/auth/me`, {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+        },
+      }).json<ApiResponse<UserInfo>>();
+
+      return response.data;
+    } catch (error: any) {
+      if (error.response?.statusCode === 401) {
+        throw new AuthenticationError('Token is invalid or expired');
+      }
+      throw error;
+    }
+  }
+
+  async checkAndRefreshTokenIfNeeded(): Promise<boolean> {
+    const config = await this.configManager.get();
+    
+    if (!config.auth?.token || !config.auth?.tokenId || !config.auth?.expiresAt) {
+      return false;
+    }
+
+    const expiresAt = new Date(config.auth.expiresAt);
+    const now = new Date();
+    const sevenDaysFromNow = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+
+    // If token expires within 7 days, refresh it
+    if (expiresAt < sevenDaysFromNow) {
+      try {
+        const refreshed = await this.refreshToken(
+          config.auth.tokenId,
+          config.auth.token
+        );
+
+        await this.configManager.update((cfg) => ({
+          ...cfg,
+          auth: {
+            ...cfg.auth,
+            token: refreshed.token,
+            expiresAt: refreshed.expiresAt,
+          },
+        }));
+
+        return true;
+      } catch {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}

package/src/core/auth/token-manager.ts

@@ -0,0 +1,47 @@
+import { ConfigManager } from '../config/config-manager.js';
+
+export class TokenManager {
+  constructor(private configManager: ConfigManager) {}
+
+  async getToken(): Promise<string | undefined> {
+    const config = await this.configManager.get();
+    return config.auth?.token;
+  }
+
+  async getTokenId(): Promise<string | undefined> {
+    const config = await this.configManager.get();
+    return config.auth?.tokenId;
+  }
+
+  async getExpiresAt(): Promise<string | undefined> {
+    const config = await this.configManager.get();
+    return config.auth?.expiresAt;
+  }
+
+  async isAuthenticated(): Promise<boolean> {
+    const token = await this.getToken();
+    if (!token) return false;
+
+    const expiresAt = await this.getExpiresAt();
+    if (!expiresAt) return false;
+
+    const expiryDate = new Date(expiresAt);
+    return expiryDate > new Date();
+  }
+
+  async getDaysUntilExpiry(): Promise<number | null> {
+    const expiresAt = await this.getExpiresAt();
+    if (!expiresAt) return null;
+
+    const expiryDate = new Date(expiresAt);
+    const now = new Date();
+    const diffMs = expiryDate.getTime() - now.getTime();
+    return Math.ceil(diffMs / (1000 * 60 * 60 * 24));
+  }
+
+  async isExpiringSoon(days = 7): Promise<boolean> {
+    const daysUntilExpiry = await this.getDaysUntilExpiry();
+    if (daysUntilExpiry === null) return false;
+    return daysUntilExpiry <= days;
+  }
+}

package/src/core/config/config-manager.ts

@@ -0,0 +1,107 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { z } from 'zod';
+import { CliConfig, CliConfigSchema } from './config-schema.js';
+
+const DEFAULT_CONFIG_DIR = path.join(os.homedir(), '.porchestra');
+const CONFIG_FILE = 'config.json';
+
+export class ConfigManager {
+  private configPath: string;
+  private config: CliConfig | null = null;
+
+  constructor() {
+    const configDir = process.env.PORCHESTRA_CONFIG_DIR || DEFAULT_CONFIG_DIR;
+    this.configPath = path.join(configDir, CONFIG_FILE);
+  }
+
+  async load(): Promise<CliConfig> {
+    try {
+      const data = await fs.readFile(this.configPath, 'utf-8');
+      const parsed = JSON.parse(data);
+      
+      // STRICT VALIDATION - throws on error
+      const validated = CliConfigSchema.parse(parsed);
+      this.config = validated;
+      return validated;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        // Return default config
+        const defaultConfig = { version: '1.0.0' } as const;
+        this.config = CliConfigSchema.parse(defaultConfig);
+        return this.config;
+      }
+      
+      // THROW on validation errors
+      if (error instanceof z.ZodError) {
+        console.error('❌ Config validation failed:');
+        error.errors.forEach((err) => {
+          console.error(`  - ${err.path.join('.')}: ${err.message}`);
+        });
+        throw new Error(`Invalid config file at ${this.configPath}. Please run 'porchestra config reset' to fix.`);
+      }
+      
+      throw error;
+    }
+  }
+
+  async save(config: CliConfig): Promise<void> {
+    try {
+      // STRICT VALIDATION before save
+      const validated = CliConfigSchema.parse(config);
+      
+      // Ensure directory exists
+      const configDir = path.dirname(this.configPath);
+      await fs.mkdir(configDir, { recursive: true });
+      
+      // Atomic write (write to temp, then rename)
+      const tempPath = `${this.configPath}.tmp`;
+      await fs.writeFile(
+        tempPath,
+        JSON.stringify(validated, null, 2),
+        'utf-8'
+      );
+      await fs.rename(tempPath, this.configPath);
+      
+      this.config = validated;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        console.error('❌ Config validation failed on save:');
+        error.errors.forEach((err) => {
+          console.error(`  - ${err.path.join('.')}: ${err.message}`);
+        });
+        throw new Error('Failed to save config: validation error');
+      }
+      throw error;
+    }
+  }
+
+  async get(): Promise<CliConfig> {
+    if (!this.config) {
+      return this.load();
+    }
+    return this.config;
+  }
+
+  async update(updater: (config: CliConfig) => CliConfig): Promise<void> {
+    const config = await this.get();
+    const updated = updater({ ...config }); // Create new object
+    await this.save(updated);
+  }
+
+  async clear(): Promise<void> {
+    try {
+      await fs.unlink(this.configPath);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+    }
+    this.config = null;
+  }
+
+  getConfigPath(): string {
+    return this.configPath;
+  }
+}

package/src/core/config/config-schema.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+
+// Simplified datetime validation - just accepts any string
+const DateTimeStringSchema = z.string().optional();
+
+export const TrackedAgentSchema = z.object({
+  agentId: z.string().uuid(),
+  agentName: z.string(),
+  agentSlug: z.string(),
+  folderPath: z.string(),
+  selectedAt: DateTimeStringSchema,
+  lastPulledAt: DateTimeStringSchema.optional(),
+  lastPulledVersion: z.string().optional(),
+});
+
+export const TrackedProjectSchema = z.object({
+  projectId: z.string().uuid(),
+  projectName: z.string(),
+  projectSlug: z.string(),
+  selectedAt: DateTimeStringSchema,
+  agents: z.array(TrackedAgentSchema),
+  lastPulledAt: DateTimeStringSchema.optional(),
+});
+
+export const CliConfigSchema = z.object({
+  auth: z.object({
+    token: z.string().optional(),
+    tokenId: z.string().uuid().optional(),
+    expiresAt: DateTimeStringSchema.optional(),
+    deviceName: z.string().optional(),
+  }).optional(),
+  
+  api: z.object({
+    baseUrl: z.string().url().default('https://api.porchestra.io/v1'),
+    skipTlsVerify: z.boolean().default(false),
+  }).default({}),
+  
+  trackedProjects: z.array(TrackedProjectSchema).default([]),
+  
+  output: z.object({
+    baseDir: z.string().default('./src/agents'),
+    createIndexFiles: z.boolean().default(true),
+  }).default({}),
+  
+  cli: z.object({
+    lastLoginAt: DateTimeStringSchema.optional(),
+    lastVersionCheck: DateTimeStringSchema.optional(),
+    latestKnownVersion: z.string().optional(),
+  }).optional(),
+  
+  version: z.literal('1.0.0'),
+});
+
+export type TrackedAgent = z.infer<typeof TrackedAgentSchema>;
+export type TrackedProject = z.infer<typeof TrackedProjectSchema>;
+export type CliConfig = z.infer<typeof CliConfigSchema>;

package/src/core/config/project-tracker.ts

@@ -0,0 +1,158 @@
+import { ConfigManager } from './config-manager.js';
+import { TrackedProject, TrackedAgent } from './config-schema.js';
+
+export interface ProjectBrief {
+  id: string;
+  name: string;
+  slug: string;
+}
+
+export interface AgentBrief {
+  id: string;
+  name: string;
+  slug: string;
+  folderPath: string;
+}
+
+export class ProjectTracker {
+  constructor(private configManager: ConfigManager) {}
+
+  async getTrackedProjects(): Promise<TrackedProject[]> {
+    const config = await this.configManager.get();
+    return config.trackedProjects || [];
+  }
+
+  async getTrackedAgents(projectId: string): Promise<TrackedAgent[]> {
+    const config = await this.configManager.get();
+    const project = config.trackedProjects?.find(p => p.projectId === projectId);
+    return project?.agents || [];
+  }
+
+  async listTrackedAgents(): Promise<Array<{ project: TrackedProject; agent: TrackedAgent }>> {
+    const projects = await this.getTrackedProjects();
+    return projects.flatMap(project =>
+      project.agents.map(agent => ({ project, agent }))
+    );
+  }
+
+  async trackProject(project: ProjectBrief, agents: AgentBrief[]): Promise<void> {
+    await this.configManager.update((config) => {
+      const existingIndex = config.trackedProjects.findIndex(
+        p => p.projectId === project.id
+      );
+
+      const trackedAgents: TrackedAgent[] = agents.map(agent => ({
+        agentId: agent.id,
+        agentName: agent.name,
+        agentSlug: agent.slug,
+        folderPath: agent.folderPath,
+        selectedAt: new Date().toISOString(),
+      }));
+
+      const trackedProject: TrackedProject = {
+        projectId: project.id,
+        projectName: project.name,
+        projectSlug: project.slug,
+        selectedAt: new Date().toISOString(),
+        agents: trackedAgents,
+      };
+
+      const newProjects = [...config.trackedProjects];
+      if (existingIndex >= 0) {
+        newProjects[existingIndex] = trackedProject;
+      } else {
+        newProjects.push(trackedProject);
+      }
+
+      return { ...config, trackedProjects: newProjects };
+    });
+  }
+
+  async untrackProject(projectId: string): Promise<void> {
+    await this.configManager.update((config) => ({
+      ...config,
+      trackedProjects: config.trackedProjects.filter(
+        p => p.projectId !== projectId
+      ),
+    }));
+  }
+
+  async untrackAgent(projectId: string, agentId: string): Promise<boolean> {
+    let removed = false;
+
+    await this.configManager.update((config) => {
+      const projectIndex = config.trackedProjects.findIndex(
+        p => p.projectId === projectId
+      );
+
+      if (projectIndex === -1) return config;
+
+      const project = config.trackedProjects[projectIndex];
+      const remainingAgents = project.agents.filter(
+        agent => agent.agentId !== agentId
+      );
+
+      if (remainingAgents.length === project.agents.length) {
+        return config;
+      }
+
+      removed = true;
+
+      const newProjects = [...config.trackedProjects];
+
+      if (remainingAgents.length === 0) {
+        newProjects.splice(projectIndex, 1);
+      } else {
+        newProjects[projectIndex] = { ...project, agents: remainingAgents };
+      }
+
+      return { ...config, trackedProjects: newProjects };
+    });
+
+    return removed;
+  }
+
+  async updateLastPulled(
+    projectId: string,
+    agentId: string,
+    version: string
+  ): Promise<void> {
+    await this.configManager.update((config) => {
+      const projectIndex = config.trackedProjects.findIndex(
+        p => p.projectId === projectId
+      );
+      if (projectIndex === -1) return config;
+
+      const project = config.trackedProjects[projectIndex];
+      const agentIndex = project.agents.findIndex(
+        a => a.agentId === agentId
+      );
+      if (agentIndex === -1) return config;
+
+      const now = new Date().toISOString();
+      const newAgents = [...project.agents];
+      newAgents[agentIndex] = {
+        ...newAgents[agentIndex],
+        lastPulledAt: now,
+        lastPulledVersion: version,
+      };
+
+      const newProjects = [...config.trackedProjects];
+      newProjects[projectIndex] = {
+        ...project,
+        agents: newAgents,
+        lastPulledAt: now,
+      };
+
+      return { ...config, trackedProjects: newProjects };
+    });
+  }
+
+  async getSummary(): Promise<{ projectCount: number; agentCount: number }> {
+    const projects = await this.getTrackedProjects();
+    return {
+      projectCount: projects.length,
+      agentCount: projects.reduce((sum, p) => sum + p.agents.length, 0),
+    };
+  }
+}