@sumicom/quicksave 0.1.0

package/src/handlers/messageHandler.ts

@@ -0,0 +1,550 @@
+import {
+  Message,
+  createMessage,
+  StatusRequestPayload,
+  StatusResponsePayload,
+  DiffRequestPayload,
+  DiffResponsePayload,
+  StageRequestPayload,
+  StageResponsePayload,
+  UnstageRequestPayload,
+  UnstageResponsePayload,
+  StagePatchRequestPayload,
+  StagePatchResponsePayload,
+  UnstagePatchRequestPayload,
+  UnstagePatchResponsePayload,
+  CommitRequestPayload,
+  CommitResponsePayload,
+  LogRequestPayload,
+  LogResponsePayload,
+  BranchesResponsePayload,
+  CheckoutRequestPayload,
+  CheckoutResponsePayload,
+  DiscardRequestPayload,
+  DiscardResponsePayload,
+  ErrorPayload,
+  HandshakePayload,
+  HandshakeAckPayload,
+  License,
+  GenerateCommitSummaryRequestPayload,
+  GenerateCommitSummaryResponsePayload,
+  SetApiKeyRequestPayload,
+  SetApiKeyResponsePayload,
+  GetApiKeyStatusResponsePayload,
+  Repository,
+  ListReposResponsePayload,
+  SwitchRepoRequestPayload,
+  SwitchRepoResponsePayload,
+  BrowseDirectoryRequestPayload,
+  BrowseDirectoryResponsePayload,
+  DirectoryEntry,
+  AddRepoRequestPayload,
+  AddRepoResponsePayload,
+} from '@sumicom/quicksave-shared';
+import { GitOperations } from '../git/operations.js';
+import { getAnthropicApiKey, setAnthropicApiKey, hasAnthropicApiKey } from '../config.js';
+import { CommitSummaryService } from '../ai/commitSummary.js';
+import { readdir, stat } from 'fs/promises';
+import { join, dirname, basename } from 'path';
+import { homedir } from 'os';
+
+export class MessageHandler {
+  private repos: Map<string, GitOperations>;
+  private agentVersion = '0.1.0';
+  private currentRepoPath: string;
+  private availableRepos: Repository[];
+  private aiService: CommitSummaryService | null = null;
+
+  constructor(repos: Repository[], _license?: License) {
+    this.repos = new Map();
+    for (const repo of repos) {
+      this.repos.set(repo.path, new GitOperations(repo.path));
+    }
+    this.availableRepos = repos;
+    this.currentRepoPath = repos[0].path;
+    // License handling will be implemented later
+  }
+
+  private get git(): GitOperations {
+    return this.repos.get(this.currentRepoPath)!;
+  }
+
+  private getAiService(): CommitSummaryService | null {
+    const apiKey = getAnthropicApiKey();
+    if (!apiKey) return null;
+
+    // Create service lazily and reuse for caching
+    if (!this.aiService) {
+      this.aiService = new CommitSummaryService(apiKey);
+    }
+    return this.aiService;
+  }
+
+  async handleMessage(message: Message): Promise<Message> {
+    try {
+      switch (message.type) {
+        case 'handshake':
+          return this.handleHandshake(message as Message<HandshakePayload>);
+        case 'ping':
+          return createMessage('pong', { timestamp: Date.now() });
+        case 'git:status':
+          return this.handleStatus(message as Message<StatusRequestPayload>);
+        case 'git:diff':
+          return this.handleDiff(message as Message<DiffRequestPayload>);
+        case 'git:stage':
+          return this.handleStage(message as Message<StageRequestPayload>);
+        case 'git:unstage':
+          return this.handleUnstage(message as Message<UnstageRequestPayload>);
+        case 'git:stage-patch':
+          return this.handleStagePatch(message as Message<StagePatchRequestPayload>);
+        case 'git:unstage-patch':
+          return this.handleUnstagePatch(message as Message<UnstagePatchRequestPayload>);
+        case 'git:commit':
+          return this.handleCommit(message as Message<CommitRequestPayload>);
+        case 'git:log':
+          return this.handleLog(message as Message<LogRequestPayload>);
+        case 'git:branches':
+          return this.handleBranches();
+        case 'git:checkout':
+          return this.handleCheckout(message as Message<CheckoutRequestPayload>);
+        case 'git:discard':
+          return this.handleDiscard(message as Message<DiscardRequestPayload>);
+        case 'ai:generate-commit-summary':
+          return this.handleGenerateCommitSummary(message as Message<GenerateCommitSummaryRequestPayload>);
+        case 'ai:set-api-key':
+          return this.handleSetApiKey(message as Message<SetApiKeyRequestPayload>);
+        case 'ai:get-api-key-status':
+          return this.handleGetApiKeyStatus(message);
+        case 'agent:list-repos':
+          return this.handleListRepos(message);
+        case 'agent:switch-repo':
+          return this.handleSwitchRepo(message as Message<SwitchRepoRequestPayload>);
+        case 'agent:browse-directory':
+          return this.handleBrowseDirectory(message as Message<BrowseDirectoryRequestPayload>);
+        case 'agent:add-repo':
+          return this.handleAddRepo(message as Message<AddRepoRequestPayload>);
+        default:
+          return this.createErrorResponse(message.id, 'UNKNOWN_MESSAGE_TYPE', `Unknown message type: ${message.type}`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return this.createErrorResponse(message.id, 'HANDLER_ERROR', errorMessage);
+    }
+  }
+
+  private handleHandshake(message: Message<HandshakePayload>): Message<HandshakeAckPayload> {
+    const response = createMessage<HandshakeAckPayload>('handshake:ack', {
+      success: true,
+      agentVersion: this.agentVersion,
+      repoPath: this.currentRepoPath,
+      availableRepos: this.availableRepos,
+    });
+    response.id = message.id;
+    return response;
+  }
+
+  private async handleStatus(message: Message<StatusRequestPayload>): Promise<Message<StatusResponsePayload>> {
+    const status = await this.git.getStatus();
+    const response = createMessage<StatusResponsePayload>('git:status:response', status);
+    response.id = message.id;
+    return response;
+  }
+
+  private async handleDiff(message: Message<DiffRequestPayload>): Promise<Message<DiffResponsePayload>> {
+    const { path, staged } = message.payload;
+    const diff = await this.git.getDiff(path, staged);
+    const response = createMessage<DiffResponsePayload>('git:diff:response', diff);
+    response.id = message.id;
+    return response;
+  }
+
+  private async handleStage(message: Message<StageRequestPayload>): Promise<Message<StageResponsePayload>> {
+    try {
+      await this.git.stage(message.payload.paths);
+      const response = createMessage<StageResponsePayload>('git:stage:response', { success: true });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<StageResponsePayload>('git:stage:response', {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to stage files',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private async handleUnstage(message: Message<UnstageRequestPayload>): Promise<Message<UnstageResponsePayload>> {
+    try {
+      await this.git.unstage(message.payload.paths);
+      const response = createMessage<UnstageResponsePayload>('git:unstage:response', { success: true });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<UnstageResponsePayload>('git:unstage:response', {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to unstage files',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private async handleStagePatch(message: Message<StagePatchRequestPayload>): Promise<Message<StagePatchResponsePayload>> {
+    try {
+      await this.git.stagePatch(message.payload.patch);
+      const response = createMessage<StagePatchResponsePayload>('git:stage-patch:response', { success: true });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<StagePatchResponsePayload>('git:stage-patch:response', {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to stage patch',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private async handleUnstagePatch(message: Message<UnstagePatchRequestPayload>): Promise<Message<UnstagePatchResponsePayload>> {
+    try {
+      await this.git.unstagePatch(message.payload.patch);
+      const response = createMessage<UnstagePatchResponsePayload>('git:unstage-patch:response', { success: true });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<UnstagePatchResponsePayload>('git:unstage-patch:response', {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to unstage patch',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private async handleCommit(message: Message<CommitRequestPayload>): Promise<Message<CommitResponsePayload>> {
+    try {
+      const { message: commitMessage, description } = message.payload;
+      const hash = await this.git.commit(commitMessage, description);
+      const response = createMessage<CommitResponsePayload>('git:commit:response', {
+        success: true,
+        hash,
+      });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<CommitResponsePayload>('git:commit:response', {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to commit',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private async handleLog(message: Message<LogRequestPayload>): Promise<Message<LogResponsePayload>> {
+    const limit = message.payload.limit || 50;
+    const commits = await this.git.getLog(limit);
+    const response = createMessage<LogResponsePayload>('git:log:response', { commits });
+    response.id = message.id;
+    return response;
+  }
+
+  private async handleBranches(): Promise<Message<BranchesResponsePayload>> {
+    const { branches, current } = await this.git.getBranches();
+    return createMessage<BranchesResponsePayload>('git:branches:response', {
+      branches,
+      current,
+    });
+  }
+
+  private async handleCheckout(message: Message<CheckoutRequestPayload>): Promise<Message<CheckoutResponsePayload>> {
+    try {
+      const { branch, create } = message.payload;
+      await this.git.checkout(branch, create);
+      const response = createMessage<CheckoutResponsePayload>('git:checkout:response', { success: true });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<CheckoutResponsePayload>('git:checkout:response', {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to checkout',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private async handleDiscard(message: Message<DiscardRequestPayload>): Promise<Message<DiscardResponsePayload>> {
+    try {
+      await this.git.discard(message.payload.paths);
+      const response = createMessage<DiscardResponsePayload>('git:discard:response', { success: true });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<DiscardResponsePayload>('git:discard:response', {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to discard changes',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private async handleGenerateCommitSummary(
+    message: Message<GenerateCommitSummaryRequestPayload>
+  ): Promise<Message<GenerateCommitSummaryResponsePayload>> {
+    const aiService = this.getAiService();
+
+    if (!aiService) {
+      const response = createMessage<GenerateCommitSummaryResponsePayload>(
+        'ai:generate-commit-summary:response',
+        {
+          success: false,
+          error: 'Configure your API key in Settings',
+          errorCode: 'NO_API_KEY',
+        }
+      );
+      response.id = message.id;
+      return response;
+    }
+
+    try {
+      const status = await this.git.getStatus();
+      if (status.staged.length === 0) {
+        const response = createMessage<GenerateCommitSummaryResponsePayload>(
+          'ai:generate-commit-summary:response',
+          {
+            success: false,
+            error: 'No staged changes to summarize',
+            errorCode: 'NO_STAGED_CHANGES',
+          }
+        );
+        response.id = message.id;
+        return response;
+      }
+
+      // Collect diffs for all staged files
+      const diffs = await Promise.all(status.staged.map((file) => this.git.getDiff(file.path, true)));
+
+      // Generate summary (uses internal queue and cache)
+      const result = await aiService.generateSummary({
+        diffs,
+        context: message.payload.context,
+        model: message.payload.model,
+      });
+
+      const response = createMessage<GenerateCommitSummaryResponsePayload>(
+        'ai:generate-commit-summary:response',
+        {
+          success: true,
+          summary: result.summary,
+          description: result.description,
+          tokenUsage: result.tokenUsage,
+          cached: result.cached,
+        }
+      );
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to generate summary';
+      const isRateLimit = errorMessage.includes('rate_limit');
+
+      const response = createMessage<GenerateCommitSummaryResponsePayload>(
+        'ai:generate-commit-summary:response',
+        {
+          success: false,
+          error: errorMessage,
+          errorCode: isRateLimit ? 'RATE_LIMITED' : 'API_ERROR',
+        }
+      );
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private handleSetApiKey(message: Message<SetApiKeyRequestPayload>): Message<SetApiKeyResponsePayload> {
+    try {
+      setAnthropicApiKey(message.payload.apiKey);
+      const response = createMessage<SetApiKeyResponsePayload>('ai:set-api-key:response', {
+        success: true,
+      });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<SetApiKeyResponsePayload>('ai:set-api-key:response', {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to save API key',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private handleGetApiKeyStatus(message: Message): Message<GetApiKeyStatusResponsePayload> {
+    const response = createMessage<GetApiKeyStatusResponsePayload>('ai:get-api-key-status:response', {
+      configured: hasAnthropicApiKey(),
+    });
+    response.id = message.id;
+    return response;
+  }
+
+  private async handleListRepos(message: Message): Promise<Message<ListReposResponsePayload>> {
+    // Refresh branch info for all repos
+    const repos: Repository[] = [];
+    for (const repo of this.availableRepos) {
+      const git = this.repos.get(repo.path)!;
+      try {
+        const { current } = await git.getBranches();
+        repos.push({ ...repo, currentBranch: current });
+      } catch {
+        repos.push(repo);
+      }
+    }
+    const response = createMessage<ListReposResponsePayload>('agent:list-repos:response', {
+      repos,
+      current: this.currentRepoPath,
+    });
+    response.id = message.id;
+    return response;
+  }
+
+  private handleSwitchRepo(message: Message<SwitchRepoRequestPayload>): Message<SwitchRepoResponsePayload> {
+    const { path } = message.payload;
+
+    // Check if the requested repo is in our available repos
+    if (!this.repos.has(path)) {
+      const response = createMessage<SwitchRepoResponsePayload>('agent:switch-repo:response', {
+        success: false,
+        newPath: this.currentRepoPath,
+        error: `Repository not available: ${path}`,
+      });
+      response.id = message.id;
+      return response;
+    }
+
+    this.currentRepoPath = path;
+    const response = createMessage<SwitchRepoResponsePayload>('agent:switch-repo:response', {
+      success: true,
+      newPath: path,
+    });
+    response.id = message.id;
+    return response;
+  }
+
+  private async handleBrowseDirectory(
+    message: Message<BrowseDirectoryRequestPayload>
+  ): Promise<Message<BrowseDirectoryResponsePayload>> {
+    const requestedPath = message.payload.path || homedir();
+
+    try {
+      const entries: DirectoryEntry[] = [];
+      const dirEntries = await readdir(requestedPath, { withFileTypes: true });
+
+      for (const entry of dirEntries) {
+        // Skip hidden files/folders (starting with .)
+        if (entry.name.startsWith('.')) continue;
+
+        const fullPath = join(requestedPath, entry.name);
+        const isDirectory = entry.isDirectory();
+
+        // Check if it's a git repo (has .git folder)
+        let isGitRepo = false;
+        if (isDirectory) {
+          try {
+            const gitPath = join(fullPath, '.git');
+            const gitStat = await stat(gitPath);
+            isGitRepo = gitStat.isDirectory();
+          } catch {
+            // Not a git repo
+          }
+        }
+
+        entries.push({
+          name: entry.name,
+          path: fullPath,
+          isDirectory,
+          isGitRepo,
+        });
+      }
+
+      // Sort: directories first, then alphabetically
+      entries.sort((a, b) => {
+        if (a.isDirectory && !b.isDirectory) return -1;
+        if (!a.isDirectory && b.isDirectory) return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+      // Calculate parent path
+      const parentPath = requestedPath === '/' ? null : dirname(requestedPath);
+
+      const response = createMessage<BrowseDirectoryResponsePayload>('agent:browse-directory:response', {
+        path: requestedPath,
+        parentPath,
+        entries,
+      });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<BrowseDirectoryResponsePayload>('agent:browse-directory:response', {
+        path: requestedPath,
+        parentPath: dirname(requestedPath),
+        entries: [],
+        error: error instanceof Error ? error.message : 'Failed to read directory',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private async handleAddRepo(
+    message: Message<AddRepoRequestPayload>
+  ): Promise<Message<AddRepoResponsePayload>> {
+    const { path: repoPath } = message.payload;
+
+    // Check if already added
+    if (this.repos.has(repoPath)) {
+      const response = createMessage<AddRepoResponsePayload>('agent:add-repo:response', {
+        success: false,
+        error: 'Repository already added',
+      });
+      response.id = message.id;
+      return response;
+    }
+
+    try {
+      // Verify it's a git repo by trying to get branches
+      const git = new GitOperations(repoPath);
+      const { current } = await git.getBranches();
+
+      // Add to our maps
+      this.repos.set(repoPath, git);
+      const newRepo: Repository = {
+        path: repoPath,
+        name: basename(repoPath),
+        currentBranch: current,
+      };
+      this.availableRepos.push(newRepo);
+
+      const response = createMessage<AddRepoResponsePayload>('agent:add-repo:response', {
+        success: true,
+        repo: newRepo,
+      });
+      response.id = message.id;
+      return response;
+    } catch (error) {
+      const response = createMessage<AddRepoResponsePayload>('agent:add-repo:response', {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to add repository',
+      });
+      response.id = message.id;
+      return response;
+    }
+  }
+
+  private createErrorResponse(id: string, code: string, message: string): Message<ErrorPayload> {
+    const response = createMessage<ErrorPayload>('error', { code, message });
+    response.id = id;
+    return response;
+  }
+}

package/src/index.ts

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+// @ts-ignore - no types for qrcode-terminal
+import qrcode from 'qrcode-terminal';
+import { resolve, basename } from 'path';
+import { WebRTCConnection } from './connection/connection.js';
+import { MessageHandler } from './handlers/messageHandler.js';
+import { GitOperations } from './git/operations.js';
+import { getOrCreateConfig, getConfigPath } from './config.js';
+import type { Message, Repository } from '@sumicom/quicksave-shared';
+
+const DEFAULT_SIGNALING_SERVER = process.env.QUICKSAVE_SIGNALING_URL || 'wss://signal.quicksave.dev';
+
+const program = new Command();
+
+function collectRepos(value: string, previous: string[]): string[] {
+  return previous.concat([value]);
+}
+
+program
+  .name('quicksave-agent')
+  .description('Quicksave desktop agent for remote git control')
+  .version('0.1.0')
+  .option('-r, --repo <path>', 'Path to git repository (can specify multiple)', collectRepos, [])
+  .option('-s, --signaling <url>', 'Signaling server URL', DEFAULT_SIGNALING_SERVER)
+  .option('--no-qr', 'Disable QR code display')
+  .action(async (options) => {
+    // Default to current directory if no repos specified
+    const repoPaths: string[] = options.repo.length > 0 ? options.repo : ['.'];
+    const resolvedPaths = repoPaths.map((p: string) => resolve(p));
+    const signalingServer = options.signaling;
+
+    console.log('Quicksave Agent v0.1.0');
+    console.log('='.repeat(50));
+
+    // Verify all git repositories
+    const validRepos: Repository[] = [];
+    for (const repoPath of resolvedPaths) {
+      const git = new GitOperations(repoPath);
+      const isValid = await git.isValidRepo();
+      if (!isValid) {
+        console.error(`Warning: ${repoPath} is not a valid git repository, skipping`);
+        continue;
+      }
+      const { current: currentBranch } = await git.getBranches();
+      validRepos.push({
+        path: repoPath,
+        name: basename(repoPath),
+        currentBranch,
+      });
+    }
+
+    if (validRepos.length === 0) {
+      console.error('Error: No valid git repositories found');
+      process.exit(1);
+    }
+
+    console.log(`Repositories (${validRepos.length}):`);
+    for (const repo of validRepos) {
+      console.log(`  - ${repo.name} (${repo.path}) [${repo.currentBranch}]`);
+    }
+
+    // Load or create config
+    const config = getOrCreateConfig(signalingServer);
+    console.log(`Config: ${getConfigPath()}`);
+    console.log(`Signaling: ${signalingServer}`);
+    console.log('');
+
+    // Create connection
+    const connection = new WebRTCConnection({
+      signalingServer,
+      agentId: config.agentId,
+      keyPair: config.keyPair,
+    });
+
+    // Create message handler with all valid repos
+    const messageHandler = new MessageHandler(validRepos, config.license);
+
+    // Handle incoming messages
+    connection.on('message', async (message: Message) => {
+      const response = await messageHandler.handleMessage(message);
+      connection.send(response);
+    });
+
+    connection.on('connected', () => {
+      console.log('\n✓ PWA connected! Ready for git operations.');
+    });
+
+    connection.on('disconnected', () => {
+      console.log('\n✗ PWA disconnected. Waiting for reconnection...');
+      displayConnectionInfo(config.agentId, config.keyPair.publicKey, options.qr);
+    });
+
+    connection.on('error', (error) => {
+      console.error('Connection error:', error.message);
+    });
+
+    // Start connection
+    try {
+      await connection.start();
+      displayConnectionInfo(config.agentId, config.keyPair.publicKey, options.qr);
+    } catch (error) {
+      console.error('Failed to start agent:', error);
+      process.exit(1);
+    }
+
+    // Handle shutdown
+    process.on('SIGINT', () => {
+      console.log('\nShutting down...');
+      connection.disconnect();
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', () => {
+      connection.disconnect();
+      process.exit(0);
+    });
+  });
+
+function displayConnectionInfo(agentId: string, publicKey: string, showQr: boolean): void {
+  console.log('');
+  console.log('='.repeat(50));
+  console.log('Connection Info');
+  console.log('='.repeat(50));
+  console.log('');
+  console.log('Agent ID:');
+  console.log(`  ${agentId}`);
+  console.log('');
+  console.log('Public Key:');
+  console.log(`  ${publicKey}`);
+  console.log('');
+
+  // Create connection URL for PWA
+  const connectionUrl = `https://quicksave.dev/connect?id=${agentId}&pk=${encodeURIComponent(publicKey)}`;
+
+  console.log('Connection URL:');
+  console.log(`  ${connectionUrl}`);
+  console.log('');
+
+  if (showQr) {
+    console.log('Scan QR code to connect:');
+    console.log('');
+    qrcode.generate(connectionUrl, { small: true });
+  }
+
+  console.log('');
+  console.log('Waiting for PWA connection...');
+}
+
+program.parse();