happy-coder 0.1.7 → 0.1.9

package/dist/uninstall-C42CoSCI.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var types = require('./types-mykDX2xe.cjs');
+var fs = require('fs');
+var child_process = require('child_process');
+require('axios');
+require('chalk');
+require('node:os');
+require('node:path');
+require('node:fs/promises');
+require('node:fs');
+require('node:events');
+require('socket.io-client');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('expo-server-sdk');
+
+const PLIST_LABEL = "com.happy-cli.daemon";
+const PLIST_FILE = `/Library/LaunchDaemons/${PLIST_LABEL}.plist`;
+async function uninstall$1() {
+  try {
+    if (!fs.existsSync(PLIST_FILE)) {
+      types.logger.info("Daemon plist not found. Nothing to uninstall.");
+      return;
+    }
+    try {
+      child_process.execSync(`launchctl unload ${PLIST_FILE}`, { stdio: "inherit" });
+      types.logger.info("Daemon stopped successfully");
+    } catch (error) {
+      types.logger.info("Failed to unload daemon (it might not be running)");
+    }
+    fs.unlinkSync(PLIST_FILE);
+    types.logger.info(`Removed daemon plist from ${PLIST_FILE}`);
+    types.logger.info("Daemon uninstalled successfully");
+  } catch (error) {
+    types.logger.debug("Failed to uninstall daemon:", error);
+    throw error;
+  }
+}
+
+async function uninstall() {
+  if (process.platform !== "darwin") {
+    throw new Error("Daemon uninstallation is currently only supported on macOS");
+  }
+  if (process.getuid && process.getuid() !== 0) {
+    throw new Error("Daemon uninstallation requires sudo privileges. Please run with sudo.");
+  }
+  types.logger.info("Uninstalling Happy CLI daemon for macOS...");
+  await uninstall$1();
+}
+
+exports.uninstall = uninstall;

package/dist/uninstall-CLkTtlMv.mjs

@@ -0,0 +1,51 @@
+import { l as logger } from './types-fXgEaaqP.mjs';
+import { existsSync, unlinkSync } from 'fs';
+import { execSync } from 'child_process';
+import 'axios';
+import 'chalk';
+import 'node:os';
+import 'node:path';
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:events';
+import 'socket.io-client';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'expo-server-sdk';
+
+const PLIST_LABEL = "com.happy-cli.daemon";
+const PLIST_FILE = `/Library/LaunchDaemons/${PLIST_LABEL}.plist`;
+async function uninstall$1() {
+  try {
+    if (!existsSync(PLIST_FILE)) {
+      logger.info("Daemon plist not found. Nothing to uninstall.");
+      return;
+    }
+    try {
+      execSync(`launchctl unload ${PLIST_FILE}`, { stdio: "inherit" });
+      logger.info("Daemon stopped successfully");
+    } catch (error) {
+      logger.info("Failed to unload daemon (it might not be running)");
+    }
+    unlinkSync(PLIST_FILE);
+    logger.info(`Removed daemon plist from ${PLIST_FILE}`);
+    logger.info("Daemon uninstalled successfully");
+  } catch (error) {
+    logger.debug("Failed to uninstall daemon:", error);
+    throw error;
+  }
+}
+
+async function uninstall() {
+  if (process.platform !== "darwin") {
+    throw new Error("Daemon uninstallation is currently only supported on macOS");
+  }
+  if (process.getuid && process.getuid() !== 0) {
+    throw new Error("Daemon uninstallation requires sudo privileges. Please run with sudo.");
+  }
+  logger.info("Uninstalling Happy CLI daemon for macOS...");
+  await uninstall$1();
+}
+
+export { uninstall };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "happy-coder",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Claude Code session sharing CLI",
   "author": "Kirill Dubovitskiy",
   "license": "MIT",
@@ -15,19 +15,32 @@
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
   "exports": {
-    "require": {
-      "types": "./dist/index.d.cts",
-      "default": "./dist/index.cjs"
+    ".": {
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
     },
-    "import": {
-      "types": "./dist/index.d.mts",
-      "default": "./dist/index.mjs"
+    "./lib": {
+      "require": {
+        "types": "./dist/lib.d.cts",
+        "default": "./dist/lib.cjs"
+      },
+      "import": {
+        "types": "./dist/lib.d.mts",
+        "default": "./dist/lib.mjs"
+      }
     }
   },
   "files": [
     "dist",
     "bin",
-    "scripts"
+    "scripts",
+    "package.json"
   ],
   "scripts": {
     "test": "vitest run",
@@ -35,16 +48,18 @@
     "build": "pkgroll",
     "prepublishOnly": "tsc --noEmit && yarn build && yarn test",
     "dev": "npx tsx --env-file .env.sample src/index.ts",
-    "dev:local": "HANDY_SERVER_URL=http://localhost:3005 npx tsx --env-file .env.sample src/index.ts"
+    "dev:local-server": "HANDY_SERVER_URL=http://localhost:3005 npx tsx --env-file .env.sample src/index.ts"
   },
   "dependencies": {
     "@anthropic-ai/claude-code": "^1.0.51",
     "@anthropic-ai/sdk": "^0.56.0",
     "@modelcontextprotocol/sdk": "^1.15.1",
+    "@stablelib/base64": "^2.0.1",
     "@types/qrcode-terminal": "^0.12.2",
     "axios": "^1.10.0",
     "chalk": "^5.4.1",
     "expo-server-sdk": "^3.15.0",
+    "http-proxy-middleware": "^3.0.5",
     "qrcode-terminal": "^0.12.0",
     "socket.io-client": "^4.8.1",
     "tweetnacl": "^1.0.3",
@@ -62,4 +77,4 @@
     "typescript": "^5",
     "vitest": "^3.2.4"
   }
-}
+}

package/dist/auth/auth.d.ts

@@ -1,38 +0,0 @@
-/**
- * Authentication module for handy-cli
- *
- * This module handles authentication with the handy server using public key cryptography.
- * It manages secret key generation, storage, and the authentication flow.
- *
- * Key responsibilities:
- * - Generate and persist secret keys
- * - Implement challenge-response authentication
- * - Obtain and manage auth tokens
- *
- * Design decisions:
- * - Secret keys are stored in the user's home directory for persistence
- * - Uses tweetnacl for cryptographic operations
- * - Auth tokens are kept in memory only (not persisted)
- */
-/**
- * Generate or load a secret key for authentication
- * Creates a new key if one doesn't exist, otherwise loads the existing key
- */
-export declare function getOrCreateSecretKey(): Promise<Uint8Array>;
-/**
- * Generate authentication challenge response
- */
-export declare function authChallenge(secret: Uint8Array): {
-    challenge: Uint8Array;
-    publicKey: Uint8Array;
-    signature: Uint8Array;
-};
-/**
- * Authenticate with the server and obtain an auth token
- */
-export declare function authGetToken(serverUrl: string, secret: Uint8Array): Promise<string>;
-/**
- * Generate handy:// URL with the secret key encoded in base64url format
- * This URL is used for QR code generation to allow mobile clients to connect
- */
-export declare function generateHandyUrl(secret: Uint8Array): string;

package/dist/auth/auth.js

@@ -1,76 +0,0 @@
-/**
- * Authentication module for handy-cli
- *
- * This module handles authentication with the handy server using public key cryptography.
- * It manages secret key generation, storage, and the authentication flow.
- *
- * Key responsibilities:
- * - Generate and persist secret keys
- * - Implement challenge-response authentication
- * - Obtain and manage auth tokens
- *
- * Design decisions:
- * - Secret keys are stored in the user's home directory for persistence
- * - Uses tweetnacl for cryptographic operations
- * - Auth tokens are kept in memory only (not persisted)
- */
-import { getSecretKeyPath } from '#utils/paths';
-import axios from 'axios';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { chmod } from 'node:fs/promises';
-import nacl from 'tweetnacl';
-import { encodeBase64, encodeBase64Url, getRandomBytes } from './crypto.js';
-/**
- * Generate or load a secret key for authentication
- * Creates a new key if one doesn't exist, otherwise loads the existing key
- */
-export async function getOrCreateSecretKey() {
-    const keyPath = getSecretKeyPath();
-    if (existsSync(keyPath)) {
-        const keyBase64 = readFileSync(keyPath, 'utf8').trim();
-        return new Uint8Array(Buffer.from(keyBase64, 'base64'));
-    }
-    // Generate a new 32-byte secret key (256 bits)
-    const secret = getRandomBytes(32);
-    const keyBase64 = encodeBase64(secret);
-    // Write to file with restricted permissions
-    writeFileSync(keyPath, keyBase64);
-    await chmod(keyPath, 0o600); // Read/write for owner only
-    return secret;
-}
-/**
- * Generate authentication challenge response
- */
-export function authChallenge(secret) {
-    const keypair = nacl.sign.keyPair.fromSeed(secret);
-    const challenge = getRandomBytes(32);
-    const signature = nacl.sign.detached(challenge, keypair.secretKey);
-    return {
-        challenge,
-        publicKey: keypair.publicKey,
-        signature
-    };
-}
-/**
- * Authenticate with the server and obtain an auth token
- */
-export async function authGetToken(serverUrl, secret) {
-    const { challenge, publicKey, signature } = authChallenge(secret);
-    const response = await axios.post(`${serverUrl}/v1/auth`, {
-        challenge: encodeBase64(challenge),
-        publicKey: encodeBase64(publicKey),
-        signature: encodeBase64(signature)
-    });
-    if (!response.data.success || !response.data.token) {
-        throw new Error('Authentication failed');
-    }
-    return response.data.token;
-}
-/**
- * Generate handy:// URL with the secret key encoded in base64url format
- * This URL is used for QR code generation to allow mobile clients to connect
- */
-export function generateHandyUrl(secret) {
-    const secretBase64Url = encodeBase64Url(secret);
-    return `handy://${secretBase64Url}`;
-}

package/dist/auth/auth.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Tests for the authentication module
- *
- * These tests use the real handy server API to verify authentication works correctly.
- * No mocking is used as per project requirements.
- */
-export {};

package/dist/auth/auth.test.js

@@ -1,96 +0,0 @@
-/**
- * Tests for the authentication module
- *
- * These tests use the real handy server API to verify authentication works correctly.
- * No mocking is used as per project requirements.
- */
-import { getConfig } from '#utils/config';
-import { getSecretKeyPath } from '#utils/paths';
-import { expect } from 'chai';
-import { existsSync, unlinkSync } from 'node:fs';
-import { authChallenge, authGetToken, generateHandyUrl, getOrCreateSecretKey } from './auth.js';
-import { encodeBase64 } from './crypto.js';
-describe('Authentication', () => {
-    const keyPath = getSecretKeyPath();
-    // Clean up any existing key before tests
-    beforeEach(() => {
-        if (existsSync(keyPath)) {
-            unlinkSync(keyPath);
-        }
-    });
-    // Clean up after tests
-    afterEach(() => {
-        if (existsSync(keyPath)) {
-            unlinkSync(keyPath);
-        }
-    });
-    describe('getOrCreateSecretKey', () => {
-        it('should create a new secret key if none exists', async () => {
-            const secret = await getOrCreateSecretKey();
-            expect(secret).to.be.an.instanceOf(Uint8Array);
-            expect(secret.length).to.equal(32);
-            expect(existsSync(keyPath)).to.equal(true);
-        });
-        it('should return the same key on subsequent calls', async () => {
-            const secret1 = await getOrCreateSecretKey();
-            const secret2 = await getOrCreateSecretKey();
-            expect(encodeBase64(secret1)).to.equal(encodeBase64(secret2));
-        });
-    });
-    describe('authChallenge', () => {
-        it('should generate valid challenge response', async () => {
-            const secret = await getOrCreateSecretKey();
-            const { challenge, publicKey, signature } = authChallenge(secret);
-            expect(challenge).to.be.instanceOf(Uint8Array);
-            expect(challenge.length).to.equal(32);
-            expect(signature).to.be.instanceOf(Uint8Array);
-            expect(signature.length).to.equal(64);
-            expect(publicKey).to.be.instanceOf(Uint8Array);
-            expect(publicKey.length).to.equal(32);
-        });
-    });
-    describe('authGetToken', () => {
-        it('should authenticate with the server and get a token', async () => {
-            const config = getConfig();
-            const secret = await getOrCreateSecretKey();
-            const token = await authGetToken(config.serverUrl, secret);
-            expect(token).to.be.a('string');
-            expect(token.length).to.be.greaterThan(0);
-        });
-        it('should get valid tokens for the same public key', async () => {
-            const config = getConfig();
-            const secret = await getOrCreateSecretKey();
-            const token1 = await authGetToken(config.serverUrl, secret);
-            const token2 = await authGetToken(config.serverUrl, secret);
-            // Both should be valid JWT tokens (format: header.payload.signature)
-            expect(token1.split('.')).to.have.lengthOf(3);
-            expect(token2.split('.')).to.have.lengthOf(3);
-        });
-    });
-    describe('generateHandyUrl', () => {
-        it('should generate a valid handy:// URL with base64url encoded secret', async () => {
-            const secret = await getOrCreateSecretKey();
-            const url = generateHandyUrl(secret);
-            expect(url).to.be.a('string');
-            expect(url).to.match(/^handy:\/\/[A-Za-z0-9_-]+$/);
-        });
-        it('should generate URLs that do not contain base64 padding or unsafe characters', async () => {
-            const secret = await getOrCreateSecretKey();
-            const url = generateHandyUrl(secret);
-            // Extract just the base64url part (after handy://)
-            const base64urlPart = url.slice('handy://'.length);
-            // Base64url should not contain +, /, or = characters
-            expect(base64urlPart).to.not.include('+');
-            expect(base64urlPart).to.not.include('/');
-            expect(base64urlPart).to.not.include('=');
-            // Should be base64url safe characters only
-            expect(base64urlPart).to.match(/^[A-Za-z0-9_-]+$/);
-        });
-        it('should generate consistent URLs for the same secret', async () => {
-            const secret = await getOrCreateSecretKey();
-            const url1 = generateHandyUrl(secret);
-            const url2 = generateHandyUrl(secret);
-            expect(url1).to.equal(url2);
-        });
-    });
-});

package/dist/auth/crypto.d.ts

@@ -1,25 +0,0 @@
-/**
- * Crypto utilities for handy-cli
- *
- * This module provides cryptographic functions for authentication with the handy server.
- * It handles base64 encoding/decoding and random byte generation for secret keys.
- *
- * Key responsibilities:
- * - Base64 encoding/decoding for communication with server
- * - Base64URL encoding for handy:// URL generation
- * - Secure random byte generation for secret keys
- * - Conversion between different buffer formats
- */
-/**
- * Encode a Uint8Array to base64 string
- */
-export declare function encodeBase64(buffer: Uint8Array): string;
-/**
- * Encode a Uint8Array to base64url string (URL-safe base64)
- * Base64URL uses '-' instead of '+', '_' instead of '/', and removes padding
- */
-export declare function encodeBase64Url(buffer: Uint8Array): string;
-/**
- * Generate secure random bytes
- */
-export declare function getRandomBytes(size: number): Uint8Array;

package/dist/auth/crypto.js

@@ -1,36 +0,0 @@
-/**
- * Crypto utilities for handy-cli
- *
- * This module provides cryptographic functions for authentication with the handy server.
- * It handles base64 encoding/decoding and random byte generation for secret keys.
- *
- * Key responsibilities:
- * - Base64 encoding/decoding for communication with server
- * - Base64URL encoding for handy:// URL generation
- * - Secure random byte generation for secret keys
- * - Conversion between different buffer formats
- */
-import { randomBytes } from 'node:crypto';
-/**
- * Encode a Uint8Array to base64 string
- */
-export function encodeBase64(buffer) {
-    return Buffer.from(buffer).toString('base64');
-}
-/**
- * Encode a Uint8Array to base64url string (URL-safe base64)
- * Base64URL uses '-' instead of '+', '_' instead of '/', and removes padding
- */
-export function encodeBase64Url(buffer) {
-    return Buffer.from(buffer)
-        .toString('base64')
-        .replaceAll('+', '-')
-        .replaceAll('/', '_')
-        .replaceAll('=', '');
-}
-/**
- * Generate secure random bytes
- */
-export function getRandomBytes(size) {
-    return new Uint8Array(randomBytes(size));
-}

package/dist/claude/claude.d.ts

@@ -1,54 +0,0 @@
-/**
- * Simplified Claude CLI integration
- *
- * This module provides a simple interface to spawn Claude CLI for each command.
- * Each command runs in its own process and exits when complete.
- *
- * Key responsibilities:
- * - Spawn Claude CLI with appropriate arguments
- * - Track session ID across command invocations
- * - Parse and emit Claude responses
- * - Handle process lifecycle for each command
- *
- * Design decisions:
- * - One process per command (no stdin interaction)
- * - Session ID persisted in memory only
- * - Kill any existing process before starting new one
- * - Simple event-based API for responses
- */
-import { EventEmitter } from 'node:events';
-export interface ClaudeOptions {
-    model?: string;
-    permissionMode?: 'auto' | 'default' | 'plan';
-    skipPermissions?: boolean;
-    workingDirectory: string;
-}
-export declare class Claude extends EventEmitter {
-    private currentProcess?;
-    private currentSessionId?;
-    /**
-     * Get the current session ID
-     */
-    getSessionId(): string | undefined;
-    /**
-     * Kill the current process if running
-     */
-    kill(): void;
-    /**
-     * Run a single Claude command
-     * Kills any existing process and spawns a new one
-     */
-    runClaudeCodeTurn(command: string, sessionId: string | undefined, options: ClaudeOptions): Promise<void>;
-    /**
-     * Build command line arguments for Claude
-     */
-    private buildArgs;
-    /**
-     * Kill the current process and wait for it to exit
-     */
-    private killAndWait;
-    /**
-     * Process a line of output from Claude
-     */
-    private processOutput;
-}

package/dist/claude/claude.js

@@ -1,170 +0,0 @@
-/**
- * Simplified Claude CLI integration
- *
- * This module provides a simple interface to spawn Claude CLI for each command.
- * Each command runs in its own process and exits when complete.
- *
- * Key responsibilities:
- * - Spawn Claude CLI with appropriate arguments
- * - Track session ID across command invocations
- * - Parse and emit Claude responses
- * - Handle process lifecycle for each command
- *
- * Design decisions:
- * - One process per command (no stdin interaction)
- * - Session ID persisted in memory only
- * - Kill any existing process before starting new one
- * - Simple event-based API for responses
- */
-import { logger } from '#utils/logger';
-import { spawn } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-// eslint-disable-next-line unicorn/prefer-event-target
-export class Claude extends EventEmitter {
-    currentProcess;
-    currentSessionId;
-    /**
-     * Get the current session ID
-     */
-    getSessionId() {
-        return this.currentSessionId;
-    }
-    /**
-     * Kill the current process if running
-     */
-    kill() {
-        if (this.currentProcess && !this.currentProcess.killed) {
-            logger.info('Killing Claude process');
-            this.currentProcess.kill();
-            this.currentProcess = undefined;
-        }
-    }
-    /**
-     * Run a single Claude command
-     * Kills any existing process and spawns a new one
-     */
-    async runClaudeCodeTurn(command, sessionId, options) {
-        // Kill any existing process - wait for it to exit
-        if (this.currentProcess && !this.currentProcess.killed) {
-            logger.info('Killing existing Claude process');
-            await this.killAndWait();
-        }
-        // Build command arguments (no session resuming for now)
-        const args = this.buildArgs(command, undefined, options);
-        logger.info('Spawning Claude CLI with args:', args);
-        // Spawn the process
-        this.currentProcess = spawn('claude', args, {
-            cwd: options.workingDirectory,
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-        // Close stdin immediately (we don't send input)
-        this.currentProcess.stdin?.end();
-        // Handle stdout (JSON responses)
-        let outputBuffer = '';
-        this.currentProcess.stdout?.on('data', (data) => {
-            outputBuffer += data.toString();
-            // Process complete lines
-            const lines = outputBuffer.split('\n');
-            outputBuffer = lines.pop() || '';
-            for (const line of lines) {
-                if (line.trim()) {
-                    this.processOutput(line);
-                }
-            }
-        });
-        // Handle stderr
-        this.currentProcess.stderr?.on('data', (data) => {
-            const error = data.toString();
-            logger.error('Claude stderr:', error);
-            this.emit('error', error);
-        });
-        // Handle process exit
-        this.currentProcess.on('exit', (code, signal) => {
-            logger.info(`Claude process exited with code ${code} and signal ${signal}`);
-            this.emit('exit', { code, signal });
-            this.currentProcess = undefined;
-        });
-        // Handle process errors
-        this.currentProcess.on('error', (error) => {
-            logger.error('Claude process error:', error);
-            this.emit('processError', error);
-            this.currentProcess = undefined;
-        });
-    }
-    /**
-     * Build command line arguments for Claude
-     */
-    buildArgs(command, sessionId, options) {
-        const args = [
-            '--print', command,
-            '--output-format', 'stream-json',
-            '--verbose'
-        ];
-        // Add model
-        if (options.model) {
-            args.push('--model', options.model);
-        }
-        // Add permission mode
-        if (options.permissionMode) {
-            const modeMap = {
-                'auto': 'acceptEdits',
-                'default': 'default',
-                'plan': 'bypassPermissions'
-            };
-            args.push('--permission-mode', modeMap[options.permissionMode]);
-        }
-        // Add skip permissions flag
-        if (options.skipPermissions) {
-            args.push('--dangerously-skip-permissions');
-        }
-        // Add session resume if we have a session ID
-        if (sessionId) {
-            args.push('--resume', sessionId);
-        }
-        return args;
-    }
-    /**
-     * Kill the current process and wait for it to exit
-     */
-    async killAndWait() {
-        if (!this.currentProcess || this.currentProcess.killed) {
-            return;
-        }
-        return new Promise((resolve) => {
-            const process = this.currentProcess;
-            // Set up exit handler
-            const exitHandler = () => {
-                this.currentProcess = undefined;
-                resolve();
-            };
-            process.once('exit', exitHandler);
-            // Kill the process
-            process.kill();
-            // Set a timeout in case the process doesn't exit
-            setTimeout(() => {
-                process.removeListener('exit', exitHandler);
-                this.currentProcess = undefined;
-                resolve();
-            }, 1000); // 1 second timeout
-        });
-    }
-    /**
-     * Process a line of output from Claude
-     */
-    processOutput(line) {
-        try {
-            const response = JSON.parse(line);
-            // Capture session ID from responses
-            if (response.session_id) {
-                this.currentSessionId = response.session_id;
-                logger.info('Session ID updated:', this.currentSessionId);
-            }
-            // Emit the parsed response
-            this.emit('response', response);
-        }
-        catch {
-            // Not JSON, emit as regular output
-            this.emit('output', line);
-        }
-    }
-}