@shykaruu/jarvis-brain 0.4.0

package/src/sites/fixtures/security-test-site/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "strict": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "target": "esnext",
+    "types": ["bun-types"]
+  }
+}

package/src/sites/git-manager.ts

@@ -0,0 +1,240 @@
+/**
+ * Site Builder — Git Manager
+ *
+ * Wraps git CLI commands via Bun.spawn for project version control.
+ */
+
+import type { GitCommit, GitBranch } from './types.ts';
+
+export class GitManager {
+  /**
+   * Check if git is installed on the system.
+   */
+  static async isInstalled(): Promise<boolean> {
+    try {
+      const proc = Bun.spawn(['git', '--version'], { stdout: 'pipe', stderr: 'pipe' });
+      const stdout = await new Response(proc.stdout).text();
+      return (await proc.exited) === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get the effective git author config (global/system level).
+   */
+  static async getGlobalAuthor(): Promise<{ name: string | null; email: string | null }> {
+    let name: string | null = null;
+    let email: string | null = null;
+    try {
+      const proc = Bun.spawn(['git', 'config', '--global', 'user.name'], { stdout: 'pipe', stderr: 'pipe' });
+      const out = await new Response(proc.stdout).text();
+      if ((await proc.exited) === 0) name = out.trim() || null;
+    } catch {}
+    try {
+      const proc = Bun.spawn(['git', 'config', '--global', 'user.email'], { stdout: 'pipe', stderr: 'pipe' });
+      const out = await new Response(proc.stdout).text();
+      if ((await proc.exited) === 0) email = out.trim() || null;
+    } catch {}
+    return { name, email };
+  }
+
+  /**
+   * Initialize a new git repo in the project directory.
+   * If author config is provided, sets it before the initial commit.
+   */
+  async init(projectPath: string, author?: { name: string; email: string; global: boolean }): Promise<void> {
+    await this.run(projectPath, ['init']);
+
+    if (author) {
+      const scope = author.global ? '--global' : '--local';
+      await this.run(projectPath, ['config', scope, 'user.name', author.name]);
+      await this.run(projectPath, ['config', scope, 'user.email', author.email]);
+    }
+
+    // Create initial commit
+    await this.run(projectPath, ['add', '-A']);
+    await this.run(projectPath, ['commit', '-m', 'Initial commit', '--allow-empty']);
+  }
+
+  /**
+   * Stage all changes and commit with a descriptive message.
+   * Returns null if there are no changes to commit.
+   */
+  async autoCommit(projectPath: string, message: string): Promise<GitCommit | null> {
+    const dirty = await this.isDirty(projectPath);
+    if (!dirty) return null;
+
+    await this.run(projectPath, ['add', '-A']);
+    await this.run(projectPath, ['commit', '-m', message]);
+
+    const log = await this.getLog(projectPath, 1);
+    return log[0] ?? null;
+  }
+
+  /**
+   * List all local branches.
+   */
+  async getBranches(projectPath: string): Promise<GitBranch[]> {
+    const output = await this.run(projectPath, ['branch', '--no-color']);
+    if (!output.trim()) return [{ name: 'main', current: true }];
+
+    return output
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => ({
+        name: line.replace(/^\*?\s+/, '').trim(),
+        current: line.startsWith('*'),
+      }));
+  }
+
+  /**
+   * Get the current branch name.
+   */
+  async getCurrentBranch(projectPath: string): Promise<string> {
+    const output = await this.run(projectPath, ['branch', '--show-current']);
+    return output.trim() || 'main';
+  }
+
+  /**
+   * Create a new branch.
+   */
+  async createBranch(projectPath: string, name: string): Promise<void> {
+    await this.run(projectPath, ['checkout', '-b', name]);
+  }
+
+  /**
+   * Switch to an existing branch.
+   */
+  async switchBranch(projectPath: string, name: string): Promise<void> {
+    await this.run(projectPath, ['checkout', name]);
+  }
+
+  /**
+   * Get commit log.
+   */
+  async getLog(projectPath: string, limit: number = 50): Promise<GitCommit[]> {
+    try {
+      const output = await this.run(projectPath, [
+        'log',
+        `--max-count=${limit}`,
+        '--format=%H|%h|%s|%an|%at',
+      ]);
+
+      if (!output.trim()) return [];
+
+      return output
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => {
+          const [hash, shortHash, message, author, dateStr] = line.split('|');
+          return {
+            hash: hash!,
+            shortHash: shortHash!,
+            message: message!,
+            author: author!,
+            date: parseInt(dateStr!, 10) * 1000,
+          };
+        });
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Check if working tree has uncommitted changes.
+   */
+  async isDirty(projectPath: string): Promise<boolean> {
+    const output = await this.run(projectPath, ['status', '--porcelain']);
+    return output.trim().length > 0;
+  }
+
+  /**
+   * Get diff of uncommitted changes.
+   */
+  async getDiff(projectPath: string): Promise<string> {
+    const staged = await this.run(projectPath, ['diff', '--cached']);
+    const unstaged = await this.run(projectPath, ['diff']);
+    return (staged + '\n' + unstaged).trim();
+  }
+
+  /**
+   * Merge a branch into the current branch.
+   */
+  async merge(projectPath: string, branch: string): Promise<{ success: boolean; conflicts?: string[] }> {
+    try {
+      await this.run(projectPath, ['merge', branch]);
+      return { success: true };
+    } catch (err) {
+      // Check for merge conflicts
+      const status = await this.run(projectPath, ['status', '--porcelain']);
+      const conflicts = status
+        .split('\n')
+        .filter(line => line.startsWith('UU') || line.startsWith('AA'))
+        .map(line => line.slice(3).trim());
+
+      if (conflicts.length > 0) {
+        return { success: false, conflicts };
+      }
+
+      // Abort the failed merge
+      try { await this.run(projectPath, ['merge', '--abort']); } catch { /* ignore */ }
+      throw err;
+    }
+  }
+
+  /**
+   * Rebase current branch onto another branch.
+   */
+  async rebase(projectPath: string, ontoBranch: string): Promise<{ success: boolean; conflicts?: string[] }> {
+    try {
+      await this.run(projectPath, ['rebase', ontoBranch]);
+      return { success: true };
+    } catch {
+      const status = await this.run(projectPath, ['status', '--porcelain']);
+      const conflicts = status
+        .split('\n')
+        .filter(line => line.startsWith('UU') || line.startsWith('AA'))
+        .map(line => line.slice(3).trim());
+
+      if (conflicts.length > 0) {
+        return { success: false, conflicts };
+      }
+
+      try { await this.run(projectPath, ['rebase', '--abort']); } catch { /* ignore */ }
+      return { success: false };
+    }
+  }
+
+  /**
+   * Delete a branch.
+   */
+  async deleteBranch(projectPath: string, name: string): Promise<void> {
+    await this.run(projectPath, ['branch', '-d', name]);
+  }
+
+  /**
+   * Run a git command in the project directory.
+   */
+  private async run(cwd: string, args: string[]): Promise<string> {
+    const proc = Bun.spawn(['git', ...args], {
+      cwd,
+      stdout: 'pipe',
+      stderr: 'pipe',
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: '0',
+      },
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      throw new Error(`git ${args[0]} failed: ${stderr.trim() || stdout.trim()}`);
+    }
+
+    return stdout;
+  }
+}

package/src/sites/github-manager.ts

@@ -0,0 +1,355 @@
+/**
+ * Site Builder — GitHub Manager
+ *
+ * Handles GitHub integration: token management (via encrypted keychain),
+ * GitHub REST API calls (create/list repos, validate token), and git
+ * remote operations (push, pull, fetch, ahead/behind status).
+ */
+
+import { getSecret, setSecret, deleteSecret, hasSecret } from '../vault/keychain.ts';
+import type { GitRemoteStatus, GitHubRepoOptions } from './types.ts';
+
+const TOKEN_KEY = 'github.personal_access_token';
+const API_BASE = 'https://api.github.com';
+
+export class GitHubManager {
+
+  // ── Token Management ──
+
+  getToken(): string | null {
+    return process.env.JARVIS_GITHUB_TOKEN ?? getSecret(TOKEN_KEY);
+  }
+
+  setToken(token: string): void {
+    setSecret(TOKEN_KEY, token);
+  }
+
+  deleteToken(): void {
+    deleteSecret(TOKEN_KEY);
+  }
+
+  hasToken(): boolean {
+    return !!process.env.JARVIS_GITHUB_TOKEN || hasSecret(TOKEN_KEY);
+  }
+
+  /**
+   * Validate the stored token against GitHub API.
+   * Returns the authenticated username and granted scopes.
+   */
+  async validateToken(): Promise<{ valid: boolean; username: string | null; scopes: string[] }> {
+    try {
+      const res = await this.githubFetch('GET', '/user');
+      const data = await res.json() as { login: string };
+      const scopes = (res.headers.get('x-oauth-scopes') ?? '').split(',').map(s => s.trim()).filter(Boolean);
+      return { valid: true, username: data.login, scopes };
+    } catch {
+      return { valid: false, username: null, scopes: [] };
+    }
+  }
+
+  // ── Repository Operations ──
+
+  /**
+   * Create a new GitHub repository under the authenticated user.
+   */
+  async createRepo(options: GitHubRepoOptions): Promise<{
+    owner: string;
+    repo: string;
+    cloneUrl: string;
+    htmlUrl: string;
+  }> {
+    const res = await this.githubFetch('POST', '/user/repos', {
+      name: options.name,
+      description: options.description ?? '',
+      private: options.private,
+      auto_init: false,
+    });
+    const data = await res.json() as {
+      owner: { login: string };
+      name: string;
+      clone_url: string;
+      html_url: string;
+    };
+    return {
+      owner: data.owner.login,
+      repo: data.name,
+      cloneUrl: data.clone_url,
+      htmlUrl: data.html_url,
+    };
+  }
+
+  /**
+   * List the authenticated user's repositories (sorted by most recently updated).
+   */
+  async listUserRepos(page = 1, perPage = 30): Promise<Array<{
+    owner: string;
+    name: string;
+    fullName: string;
+    private: boolean;
+    htmlUrl: string;
+    cloneUrl: string;
+  }>> {
+    const res = await this.githubFetch('GET', `/user/repos?sort=updated&per_page=${perPage}&page=${page}`);
+    const data = await res.json() as Array<{
+      owner: { login: string };
+      name: string;
+      full_name: string;
+      private: boolean;
+      html_url: string;
+      clone_url: string;
+    }>;
+    return data.map(r => ({
+      owner: r.owner.login,
+      name: r.name,
+      fullName: r.full_name,
+      private: r.private,
+      htmlUrl: r.html_url,
+      cloneUrl: r.clone_url,
+    }));
+  }
+
+  /**
+   * Get info about a specific repo (used when connecting to an existing repo).
+   */
+  async getRepo(owner: string, repo: string): Promise<{
+    owner: string;
+    repo: string;
+    cloneUrl: string;
+    htmlUrl: string;
+  }> {
+    const res = await this.githubFetch('GET', `/repos/${owner}/${repo}`);
+    const data = await res.json() as {
+      owner: { login: string };
+      name: string;
+      clone_url: string;
+      html_url: string;
+    };
+    return {
+      owner: data.owner.login,
+      repo: data.name,
+      cloneUrl: data.clone_url,
+      htmlUrl: data.html_url,
+    };
+  }
+
+  // ── Git Remote Operations ──
+
+  /**
+   * Add or update the 'origin' remote for a project.
+   */
+  async addRemote(projectPath: string, remoteUrl: string): Promise<void> {
+    const existing = await this.getRemoteUrl(projectPath);
+    if (existing) {
+      await this.git(projectPath, ['remote', 'set-url', 'origin', remoteUrl]);
+    } else {
+      await this.git(projectPath, ['remote', 'add', 'origin', remoteUrl]);
+    }
+  }
+
+  /**
+   * Remove the 'origin' remote.
+   */
+  async removeRemote(projectPath: string): Promise<void> {
+    try {
+      await this.git(projectPath, ['remote', 'remove', 'origin']);
+    } catch { /* already gone */ }
+  }
+
+  /**
+   * Get the current origin remote URL, or null if not set.
+   */
+  async getRemoteUrl(projectPath: string): Promise<string | null> {
+    try {
+      const url = await this.git(projectPath, ['remote', 'get-url', 'origin']);
+      return url.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Push to the origin remote. Injects token into URL for authentication.
+   */
+  async push(projectPath: string, branch?: string, force = false): Promise<{ success: boolean; error?: string }> {
+    const token = this.getToken();
+    if (!token) return { success: false, error: 'GitHub token not configured' };
+
+    const remoteUrl = await this.getRemoteUrl(projectPath);
+    if (!remoteUrl) return { success: false, error: 'No remote origin configured' };
+
+    const authUrl = this.injectToken(remoteUrl, token);
+    const targetBranch = branch ?? await this.getCurrentBranch(projectPath);
+
+    const args = ['push', '-u', authUrl, targetBranch];
+    if (force) args.splice(1, 0, '--force');
+
+    try {
+      await this.git(projectPath, args);
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  /**
+   * Pull from the origin remote.
+   */
+  async pull(projectPath: string, branch?: string): Promise<{ success: boolean; conflicts?: string[]; error?: string }> {
+    const token = this.getToken();
+    if (!token) return { success: false, error: 'GitHub token not configured' };
+
+    const remoteUrl = await this.getRemoteUrl(projectPath);
+    if (!remoteUrl) return { success: false, error: 'No remote origin configured' };
+
+    const authUrl = this.injectToken(remoteUrl, token);
+    const targetBranch = branch ?? await this.getCurrentBranch(projectPath);
+
+    try {
+      await this.git(projectPath, ['pull', authUrl, targetBranch]);
+      return { success: true };
+    } catch (err) {
+      // Check for merge conflicts
+      try {
+        const status = await this.git(projectPath, ['status', '--porcelain']);
+        const conflicts = status
+          .split('\n')
+          .filter(line => line.startsWith('UU') || line.startsWith('AA'))
+          .map(line => line.slice(3).trim());
+
+        if (conflicts.length > 0) {
+          return { success: false, conflicts };
+        }
+      } catch { /* ignore */ }
+
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  /**
+   * Fetch from origin and compute ahead/behind status.
+   */
+  async getRemoteStatus(projectPath: string): Promise<GitRemoteStatus> {
+    const remoteUrl = await this.getRemoteUrl(projectPath);
+    if (!remoteUrl) {
+      return { hasRemote: false, remoteUrl: null, owner: null, repo: null, ahead: 0, behind: 0, lastPushedAt: null };
+    }
+
+    const { owner, repo } = this.parseRemoteUrl(remoteUrl);
+    const token = this.getToken();
+
+    // Fetch latest refs from origin (requires auth)
+    if (token) {
+      const authUrl = this.injectToken(remoteUrl, token);
+      try {
+        await this.git(projectPath, ['fetch', authUrl, '--quiet']);
+      } catch { /* network error, show stale data */ }
+    }
+
+    const currentBranch = await this.getCurrentBranch(projectPath);
+    let ahead = 0;
+    let behind = 0;
+
+    try {
+      const behindStr = await this.git(projectPath, ['rev-list', '--count', `HEAD..origin/${currentBranch}`]);
+      behind = parseInt(behindStr.trim(), 10) || 0;
+    } catch { /* no tracking branch yet */ }
+
+    try {
+      const aheadStr = await this.git(projectPath, ['rev-list', '--count', `origin/${currentBranch}..HEAD`]);
+      ahead = parseInt(aheadStr.trim(), 10) || 0;
+    } catch { /* no tracking branch yet — all local commits are "ahead" */
+      try {
+        const totalStr = await this.git(projectPath, ['rev-list', '--count', 'HEAD']);
+        ahead = parseInt(totalStr.trim(), 10) || 0;
+      } catch { /* empty repo */ }
+    }
+
+    return { hasRemote: true, remoteUrl, owner, repo, ahead, behind, lastPushedAt: null };
+  }
+
+  // ── Private Helpers ──
+
+  /**
+   * Inject a token into an HTTPS GitHub URL for non-interactive auth.
+   * Converts https://github.com/owner/repo.git → https://<token>@github.com/owner/repo.git
+   */
+  private injectToken(remoteUrl: string, token: string): string {
+    try {
+      const url = new URL(remoteUrl);
+      url.username = token;
+      url.password = '';
+      return url.toString();
+    } catch {
+      // Fallback for non-standard URLs
+      return remoteUrl.replace('https://', `https://${token}@`);
+    }
+  }
+
+  /**
+   * Parse owner/repo from a GitHub remote URL.
+   */
+  private parseRemoteUrl(remoteUrl: string): { owner: string | null; repo: string | null } {
+    // Handles both https://github.com/owner/repo.git and git@github.com:owner/repo.git
+    const match = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+    if (!match) return { owner: null, repo: null };
+    return { owner: match[1]!, repo: match[2]! };
+  }
+
+  private async getCurrentBranch(projectPath: string): Promise<string> {
+    const output = await this.git(projectPath, ['branch', '--show-current']);
+    return output.trim() || 'main';
+  }
+
+  /**
+   * Run a git command via Bun.spawn.
+   */
+  private async git(cwd: string, args: string[]): Promise<string> {
+    const proc = Bun.spawn(['git', ...args], {
+      cwd,
+      stdout: 'pipe',
+      stderr: 'pipe',
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: '0',
+      },
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      throw new Error(`git ${args[0]} failed: ${stderr.trim() || stdout.trim()}`);
+    }
+
+    return stdout;
+  }
+
+  /**
+   * Make an authenticated request to the GitHub REST API.
+   */
+  private async githubFetch(method: string, path: string, body?: unknown): Promise<Response> {
+    const token = this.getToken();
+    if (!token) throw new Error('GitHub token not configured');
+
+    const url = path.startsWith('http') ? path : `${API_BASE}${path}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Accept': 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+        'User-Agent': 'JARVIS-SiteBuilder',
+        ...(body ? { 'Content-Type': 'application/json' } : {}),
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({})) as { message?: string };
+      throw new Error(`GitHub API error (${res.status}): ${err.message ?? res.statusText}`);
+    }
+
+    return res;
+  }
+}

package/src/sites/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Site Builder — Public API
+ */
+
+export { SiteBuilderService } from './service.ts';
+export { ProjectManager } from './project-manager.ts';
+export { GitManager } from './git-manager.ts';
+export { GitHubManager } from './github-manager.ts';
+export { DevServerManager } from './dev-server-manager.ts';
+export { SiteProxy } from './proxy.ts';
+export { TEMPLATES } from './templates.ts';
+export { createSiteBuilderTools } from './builder-tools.ts';
+
+export type {
+  Project,
+  ProjectMeta,
+  ProjectTemplate,
+  ProjectStatus,
+  FileEntry,
+  GitCommit,
+  GitBranch,
+  GitRemoteStatus,
+  GitHubRepoOptions,
+  SiteBuilderConfig,
+} from './types.ts';