@girardmedia/bootspring 2.0.21 → 2.0.22

package/src/core/session.ts

@@ -0,0 +1,286 @@
+/**
+ * Bootspring Session Manager
+ *
+ * Manages the current project session context linked to bootspring.com API.
+ * This tracks which project the CLI is currently working with.
+ *
+ * @package bootspring
+ * @module core/session
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export const BOOTSPRING_DIR = path.join(os.homedir(), '.bootspring');
+export const SESSION_FILE = path.join(BOOTSPRING_DIR, 'session.json');
+export const LOCAL_CONFIG_NAME = '.bootspring.json';
+
+/**
+ * Project info structure
+ */
+export interface ProjectInfo {
+  id: string;
+  name: string;
+  slug?: string | undefined;
+  lastUsed?: string | undefined;
+  [key: string]: unknown;
+}
+
+/**
+ * Session data structure
+ */
+export interface SessionData {
+  project?: ProjectInfo;
+  recentProjects?: ProjectInfo[];
+  updatedAt?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Local config structure
+ */
+export interface LocalConfig {
+  projectId?: string | undefined;
+  projectName?: string | undefined;
+  projectSlug?: string | undefined;
+  createdAt?: string | undefined;
+  _path?: string | undefined;
+  _dir?: string | undefined;
+  _fromJsConfig?: boolean | undefined;
+  [key: string]: unknown;
+}
+
+/**
+ * Effective project with source info
+ */
+export interface EffectiveProject extends ProjectInfo {
+  source: 'local' | 'session';
+  _localConfig?: LocalConfig;
+}
+
+/**
+ * Session state for display
+ */
+export interface SessionState {
+  hasSession: boolean;
+  project: EffectiveProject | null;
+  source: 'local' | 'session' | null;
+  hasLocalConfig: boolean;
+  localConfigPath?: string | undefined;
+  recentProjects: ProjectInfo[];
+  lastUpdated: string | null;
+}
+
+/**
+ * Ensure ~/.bootspring directory exists
+ */
+export function ensureDir(): void {
+  if (!fs.existsSync(BOOTSPRING_DIR)) {
+    fs.mkdirSync(BOOTSPRING_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Get current session data
+ */
+export function getSession(): SessionData | null {
+  try {
+    if (fs.existsSync(SESSION_FILE)) {
+      return JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8')) as SessionData;
+    }
+  } catch {
+    // Ignore read errors
+  }
+  return null;
+}
+
+/**
+ * Save session data
+ */
+export function saveSession(session: SessionData): void {
+  ensureDir();
+  const data = {
+    ...session,
+    updatedAt: new Date().toISOString()
+  };
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Clear session
+ */
+export function clearSession(): void {
+  try {
+    if (fs.existsSync(SESSION_FILE)) {
+      fs.unlinkSync(SESSION_FILE);
+    }
+  } catch {
+    // Ignore delete errors
+  }
+}
+
+/**
+ * Get current project context
+ */
+export function getCurrentProject(): ProjectInfo | null {
+  const session = getSession();
+  return session?.project || null;
+}
+
+/**
+ * Set current project context
+ */
+export function setCurrentProject(project: ProjectInfo): void {
+  const session = getSession() || {};
+  session.project = project;
+  saveSession(session);
+}
+
+/**
+ * Get recent projects
+ */
+export function getRecentProjects(): ProjectInfo[] {
+  const session = getSession();
+  return session?.recentProjects || [];
+}
+
+/**
+ * Add to recent projects
+ */
+export function addRecentProject(project: ProjectInfo): void {
+  const session = getSession() || {};
+  const recent = session.recentProjects || [];
+
+  // Remove if already exists
+  const filtered = recent.filter(p => p.id !== project.id);
+
+  // Add to front
+  filtered.unshift({
+    id: project.id,
+    name: project.name,
+    slug: project.slug,
+    lastUsed: new Date().toISOString()
+  });
+
+  // Keep only last 10
+  session.recentProjects = filtered.slice(0, 10);
+  saveSession(session);
+}
+
+/**
+ * Check if a local .bootspring.json or bootspring.config.js exists in cwd or ancestors
+ */
+export function findLocalConfig(startDir?: string): LocalConfig | null {
+  let dir = startDir || process.cwd();
+
+  // Walk up to 10 directories
+  for (let i = 0; i < 10; i++) {
+    // First check for .bootspring.json
+    const jsonConfigPath = path.join(dir, LOCAL_CONFIG_NAME);
+    if (fs.existsSync(jsonConfigPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(jsonConfigPath, 'utf-8')) as LocalConfig;
+        return {
+          ...config,
+          _path: jsonConfigPath,
+          _dir: dir
+        };
+      } catch {
+        // Continue to check other config files
+      }
+    }
+
+    // Also check for bootspring.config.js with projectId
+    const jsConfigPath = path.join(dir, 'bootspring.config.js');
+    if (fs.existsSync(jsConfigPath)) {
+      try {
+        // Clear require cache to get fresh config
+        delete require.cache[require.resolve(jsConfigPath)];
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const config = require(jsConfigPath) as Record<string, unknown>;
+        if (config.projectId) {
+          const project = config.project as Record<string, unknown> | undefined;
+          return {
+            projectId: config.projectId as string,
+            projectName: (project?.name || config.name || 'Unknown') as string,
+            projectSlug: project?.slug as string | undefined,
+            _path: jsConfigPath,
+            _dir: dir,
+            _fromJsConfig: true
+          };
+        }
+      } catch {
+        // Continue searching
+      }
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return null;
+}
+
+/**
+ * Get effective project context (local config > session)
+ */
+export function getEffectiveProject(): EffectiveProject | null {
+  // First check for local .bootspring.json
+  const local = findLocalConfig();
+  if (local?.projectId) {
+    return {
+      id: local.projectId,
+      name: local.projectName || 'Unknown',
+      slug: local.projectSlug,
+      source: 'local',
+      _localConfig: local
+    };
+  }
+
+  // Fall back to session
+  const sessionProject = getCurrentProject();
+  if (sessionProject) {
+    return {
+      ...sessionProject,
+      source: 'session'
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Create a local .bootspring.json file
+ */
+export function createLocalConfig(dir: string, project: ProjectInfo): string {
+  const configPath = path.join(dir, LOCAL_CONFIG_NAME);
+  const config: LocalConfig = {
+    projectId: project.id,
+    projectName: project.name,
+    projectSlug: project.slug,
+    createdAt: new Date().toISOString()
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  return configPath;
+}
+
+/**
+ * Get full session state for display
+ */
+export function getSessionState(): SessionState {
+  const session = getSession();
+  const effective = getEffectiveProject();
+  const local = findLocalConfig();
+
+  return {
+    hasSession: !!session,
+    project: effective,
+    source: effective?.source || null,
+    hasLocalConfig: !!local,
+    localConfigPath: local?._path,
+    recentProjects: session?.recentProjects || [],
+    lastUpdated: session?.updatedAt || null
+  };
+}