agent-gear 1.0.0

package/src/git-handler.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { exec } from 'child_process';
+
+vi.mock('child_process', () => ({
+  exec: vi.fn(),
+}));
+
+import { GitHandler } from './git-handler.js';
+
+function mockExecResolved(stdout: string) {
+  return vi.mocked(exec).mockImplementation(((_cmd: string, _opts: unknown, cb: (err: unknown, result: { stdout: string }) => void) => {
+    if (typeof cb === 'function') {
+      cb(null, { stdout });
+    }
+  }) as never);
+}
+
+function mockExecRejected(errorMsg: string) {
+  return vi.mocked(exec).mockImplementation(((_cmd: string, _opts: unknown, cb: (err: unknown, result: unknown) => void) => {
+    if (typeof cb === 'function') {
+      cb(new Error(errorMsg), null);
+    }
+  }) as never);
+}
+
+describe('GitHandler', () => {
+  let handler: GitHandler;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    handler = new GitHandler();
+  });
+
+  describe('check', () => {
+    it('should detect a valid git repo with branches', async () => {
+      let callCount = 0;
+      vi.mocked(exec).mockImplementation(((_cmd: string, _opts: unknown, cb: (err: unknown, result: { stdout: string }) => void) => {
+        callCount++;
+        const outputs: Record<number, string> = {
+          1: '.git\n',
+          2: 'main\n',
+          3: 'main\ndevelop\nfeature-x\n',
+        };
+        if (typeof cb === 'function') {
+          cb(null, { stdout: outputs[callCount] || '' });
+        }
+      }) as never);
+
+      const result = await handler.check('/fake/path');
+
+      expect(result.isGitRepo).toBe(true);
+      expect(result.currentBranch).toBe('main');
+      expect(result.branches).toEqual(['main', 'develop', 'feature-x']);
+      expect(result.defaultBranch).toBe('main');
+    });
+
+    it('should detect master as default if main does not exist', async () => {
+      let callCount = 0;
+      vi.mocked(exec).mockImplementation(((_cmd: string, _opts: unknown, cb: (err: unknown, result: { stdout: string }) => void) => {
+        callCount++;
+        const outputs: Record<number, string> = {
+          1: '.git\n',
+          2: 'master\n',
+          3: 'develop\nmaster\n',
+        };
+        if (typeof cb === 'function') {
+          cb(null, { stdout: outputs[callCount] || '' });
+        }
+      }) as never);
+
+      const result = await handler.check('/fake/path');
+
+      expect(result.isGitRepo).toBe(true);
+      expect(result.defaultBranch).toBe('master');
+    });
+
+    it('should sort alphabetically if neither main nor master exists', async () => {
+      let callCount = 0;
+      vi.mocked(exec).mockImplementation(((_cmd: string, _opts: unknown, cb: (err: unknown, result: { stdout: string }) => void) => {
+        callCount++;
+        const outputs: Record<number, string> = {
+          1: '.git\n',
+          2: 'feature-x\n',
+          3: 'develop\nfeature-x\n',
+        };
+        if (typeof cb === 'function') {
+          cb(null, { stdout: outputs[callCount] || '' });
+        }
+      }) as never);
+
+      const result = await handler.check('/fake/path');
+
+      expect(result.isGitRepo).toBe(true);
+      expect(result.defaultBranch).toBe('develop');
+    });
+
+    it('should return isGitRepo=false when not a git repo', async () => {
+      mockExecRejected('fatal: not a git repository');
+
+      const result = await handler.check('/fake/path');
+
+      expect(result.isGitRepo).toBe(false);
+      expect(result.currentBranch).toBeUndefined();
+      expect(result.branches).toBeUndefined();
+    });
+
+    it('should handle git-dir check returning empty string', async () => {
+      mockExecResolved('');
+
+      const result = await handler.check('/fake/path');
+
+      expect(result.isGitRepo).toBe(false);
+    });
+
+    it('should return error when branch listing fails on a valid repo', async () => {
+      vi.mocked(exec).mockImplementationOnce(((_cmd: string, _opts: unknown, cb: (err: unknown, result: { stdout: string }) => void) => {
+        if (typeof cb === 'function') cb(null, { stdout: '.git\n' });
+      }) as never);
+      vi.mocked(exec).mockImplementation(((_cmd: string, _opts: unknown, cb: (err: unknown, result: unknown) => void) => {
+        if (typeof cb === 'function') cb(new Error('git command failed'), null);
+      }) as never);
+
+      const result = await handler.check('/fake/path');
+
+      expect(result.isGitRepo).toBe(true);
+      expect(result.error).toBe('git command failed');
+    });
+  });
+
+  describe('init', () => {
+    it('should initialize git repo and rename branch to main', async () => {
+      vi.mocked(exec).mockImplementation(((_cmd: string, _opts: unknown, cb: (err: unknown, result: { stdout: string }) => void) => {
+        if (typeof cb === 'function') cb(null, { stdout: '' });
+      }) as never);
+
+      const result = await handler.init('/fake/path');
+
+      expect(result.success).toBe(true);
+      expect(exec).toHaveBeenCalledTimes(2);
+      expect(vi.mocked(exec).mock.calls[0][0]).toBe('git init');
+      expect(vi.mocked(exec).mock.calls[1][0]).toBe('git branch -m main');
+    });
+
+    it('should handle git init failure', async () => {
+      mockExecRejected('permission denied');
+
+      const result = await handler.init('/fake/path');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('permission denied');
+    });
+  });
+});

package/src/git-handler.ts

@@ -0,0 +1,75 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export interface GitCheckResult {
+  isGitRepo: boolean;
+  currentBranch?: string;
+  branches?: string[];
+  defaultBranch?: string;
+  error?: string;
+}
+
+export interface GitInitResult {
+  success: boolean;
+  error?: string;
+}
+
+export class GitHandler {
+  async check(path: string): Promise<GitCheckResult> {
+    try {
+      const { stdout: gitDir } = await execAsync('git rev-parse --git-dir', { cwd: path });
+      if (!gitDir.trim()) {
+        return { isGitRepo: false };
+      }
+    } catch {
+      return { isGitRepo: false };
+    }
+
+    try {
+      const { stdout: currentBranch } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd: path });
+      const { stdout: branchesOutput } = await execAsync('git branch --format="%(refname:short)"', { cwd: path });
+
+      const branches = branchesOutput.trim().split('\n').filter(Boolean);
+      const current = currentBranch.trim();
+
+      let defaultBranch: string;
+      if (branches.includes('main')) {
+        defaultBranch = 'main';
+      } else if (branches.includes('master')) {
+        defaultBranch = 'master';
+      } else {
+        const sorted = [...branches].sort();
+        defaultBranch = sorted[0] || current;
+      }
+
+      return {
+        isGitRepo: true,
+        currentBranch: current,
+        branches,
+        defaultBranch,
+      };
+    } catch (err) {
+      return {
+        isGitRepo: true,
+        error: err instanceof Error ? err.message : 'Unknown error',
+      };
+    }
+  }
+
+  async init(path: string): Promise<GitInitResult> {
+    try {
+      await execAsync('git init', { cwd: path });
+      await execAsync('git branch -m main', { cwd: path });
+      return { success: true };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : 'Unknown error',
+      };
+    }
+  }
+}
+
+export const gitHandler = new GitHandler();

package/src/heartbeat.ts

@@ -0,0 +1,18 @@
+const HEARTBEAT_INTERVAL_MS = 30_000;
+
+export class Heartbeat {
+  private intervalId: ReturnType<typeof setInterval> | null = null;
+
+  start(sendFn: () => void): void {
+    this.intervalId = setInterval(() => {
+      sendFn();
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+
+  stop(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { hostname } from 'os';
+import { resolveKey, resolveEndpoint, saveKeyToConfig, saveEndpointToConfig } from './config.js';
+import { connectToServer, unregister } from './socketio-client.js';
+import { writePid, removePid, isRunning } from './daemon.js';
+
+const program = new Command();
+
+program
+  .name('agent-gear')
+  .description('Agent Controller - manages connection to controller-api')
+  .version('1.0.0')
+  .option('-k, --key <key>', 'Controller key')
+  .option('-s, --server <endpoint>', 'Server endpoint URL')
+  .option('-n, --name <name>', 'Controller name')
+  .action(async (options) => {
+    if (isRunning()) {
+      console.error('Controller is already running. Stop it first or remove the PID file.');
+      process.exit(1);
+    }
+
+    const key = resolveKey(options.key);
+    if (!key) {
+      console.error('No key provided. Use --key, ZAG_CONTROLLER_KEY env, or configure in ~/.zag/config.toml');
+      process.exit(1);
+    }
+
+    const endpoint = resolveEndpoint(options.server);
+    if (!endpoint) {
+      console.error('No server endpoint provided. Use --server, ZAG_SERVER_ENDPOINT env, or configure in ~/.zag/config.toml');
+      process.exit(1);
+    }
+
+    if (options.key) saveKeyToConfig(options.key);
+    if (options.server) saveEndpointToConfig(options.server);
+
+    writePid();
+
+    const socket = connectToServer(endpoint, key, {
+      serverName: options.name || hostname(),
+    });
+
+    const shutdown = () => {
+      console.log('Shutting down...');
+      unregister(socket);
+      socket.disconnect();
+      removePid();
+      process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+    process.on('exit', () => {
+      removePid();
+    });
+  });
+
+program.parse();