happy-coder 0.1.1

package/dist/index.mjs

@@ -0,0 +1,583 @@
+import axios from 'axios';
+import * as fs from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { chmod } from 'node:fs/promises';
+import { randomBytes, randomUUID } from 'node:crypto';
+import tweetnacl from 'tweetnacl';
+import { homedir } from 'node:os';
+import { join, basename } from 'node:path';
+import chalk from 'chalk';
+import { EventEmitter } from 'node:events';
+import { io } from 'socket.io-client';
+import { z } from 'zod';
+import qrcode from 'qrcode-terminal';
+import { spawn } from 'node:child_process';
+
+function encodeBase64(buffer) {
+  return Buffer.from(buffer).toString("base64");
+}
+function encodeBase64Url(buffer) {
+  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64(base64) {
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function getRandomBytes(size) {
+  return new Uint8Array(randomBytes(size));
+}
+function encrypt(data, secret) {
+  const nonce = getRandomBytes(tweetnacl.secretbox.nonceLength);
+  const encrypted = tweetnacl.secretbox(new TextEncoder().encode(JSON.stringify(data)), nonce, secret);
+  const result = new Uint8Array(nonce.length + encrypted.length);
+  result.set(nonce);
+  result.set(encrypted, nonce.length);
+  return result;
+}
+function decrypt(data, secret) {
+  const nonce = data.slice(0, tweetnacl.secretbox.nonceLength);
+  const encrypted = data.slice(tweetnacl.secretbox.nonceLength);
+  const decrypted = tweetnacl.secretbox.open(encrypted, nonce, secret);
+  if (!decrypted) {
+    return null;
+  }
+  return JSON.parse(new TextDecoder().decode(decrypted));
+}
+function authChallenge(secret) {
+  const keypair = tweetnacl.sign.keyPair.fromSeed(secret);
+  const challenge = getRandomBytes(32);
+  const signature = tweetnacl.sign.detached(challenge, keypair.secretKey);
+  return {
+    challenge,
+    publicKey: keypair.publicKey,
+    signature
+  };
+}
+
+async function getOrCreateSecretKey() {
+  const keyPath = join(homedir(), ".handy", "access.key");
+  if (existsSync(keyPath)) {
+    const keyBase642 = readFileSync(keyPath, "utf8").trim();
+    return new Uint8Array(Buffer.from(keyBase642, "base64"));
+  }
+  const secret = getRandomBytes(32);
+  const keyBase64 = encodeBase64(secret);
+  mkdirSync(join(homedir(), ".handy"), { recursive: true });
+  writeFileSync(keyPath, keyBase64);
+  await chmod(keyPath, 384);
+  return secret;
+}
+async function authGetToken(secret) {
+  const { challenge, publicKey, signature } = authChallenge(secret);
+  const response = await axios.post(`https://handy-api.korshakov.org/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;
+}
+function generateAppUrl(secret) {
+  const secretBase64Url = encodeBase64Url(secret);
+  return `handy://${secretBase64Url}`;
+}
+
+class Logger {
+  debug(message, ...args) {
+    if (process.env.DEBUG) {
+      this.log("DEBUG" /* DEBUG */, message, ...args);
+    }
+  }
+  error(message, ...args) {
+    this.log("ERROR" /* ERROR */, message, ...args);
+  }
+  info(message, ...args) {
+    this.log("INFO" /* INFO */, message, ...args);
+  }
+  warn(message, ...args) {
+    this.log("WARN" /* WARN */, message, ...args);
+  }
+  getTimestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  log(level, message, ...args) {
+    const timestamp = this.getTimestamp();
+    const prefix = `[${timestamp}] [${level}]`;
+    switch (level) {
+      case "DEBUG" /* DEBUG */: {
+        console.log(chalk.gray(prefix), message, ...args);
+        break;
+      }
+      case "ERROR" /* ERROR */: {
+        console.error(chalk.red(prefix), message, ...args);
+        break;
+      }
+      case "INFO" /* INFO */: {
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
+      case "WARN" /* WARN */: {
+        console.log(chalk.yellow(prefix), message, ...args);
+        break;
+      }
+    }
+  }
+}
+const logger = new Logger();
+
+const SessionMessageContentSchema = z.object({
+  c: z.string(),
+  // Base64 encoded encrypted content
+  t: z.literal("encrypted")
+});
+const UpdateBodySchema = z.object({
+  message: z.object({
+    id: z.string(),
+    seq: z.number(),
+    content: SessionMessageContentSchema
+  }),
+  sid: z.string(),
+  // Session ID
+  t: z.literal("new-message")
+});
+z.object({
+  id: z.string(),
+  seq: z.number(),
+  body: UpdateBodySchema,
+  createdAt: z.number()
+});
+z.object({
+  createdAt: z.number(),
+  id: z.string(),
+  seq: z.number(),
+  updatedAt: z.number()
+});
+z.object({
+  content: SessionMessageContentSchema,
+  createdAt: z.number(),
+  id: z.string(),
+  seq: z.number(),
+  updatedAt: z.number()
+});
+z.object({
+  session: z.object({
+    id: z.string(),
+    tag: z.string(),
+    seq: z.number(),
+    createdAt: z.number(),
+    updatedAt: z.number()
+  })
+});
+const UserMessageSchema = z.object({
+  role: z.literal("user"),
+  content: z.object({
+    type: z.literal("text"),
+    text: z.string()
+  })
+});
+const AgentMessageSchema = z.object({
+  role: z.literal("agent"),
+  content: z.any()
+});
+z.union([UserMessageSchema, AgentMessageSchema]);
+
+class ApiSessionClient extends EventEmitter {
+  token;
+  secret;
+  sessionId;
+  socket;
+  receivedMessages = /* @__PURE__ */ new Set();
+  pendingMessages = [];
+  pendingMessageCallback = null;
+  constructor(token, secret, sessionId) {
+    super();
+    this.token = token;
+    this.secret = secret;
+    this.sessionId = sessionId;
+    this.socket = io("https://handy-api.korshakov.org", {
+      auth: {
+        token: this.token
+      },
+      path: "/v1/updates",
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3,
+      transports: ["websocket"],
+      withCredentials: true,
+      autoConnect: false
+    });
+    this.socket.on("connect", () => {
+      logger.info("Socket connected successfully");
+    });
+    this.socket.on("disconnect", (reason) => {
+      logger.warn("Socket disconnected:", reason);
+    });
+    this.socket.on("connect_error", (error) => {
+      logger.error("Socket connection error:", error.message);
+    });
+    this.socket.on("update", (data) => {
+      if (data.body.t === "new-message" && data.body.message.content.t === "encrypted") {
+        const body = decrypt(decodeBase64(data.body.message.content.c), this.secret);
+        const result = UserMessageSchema.safeParse(body);
+        if (result.success) {
+          if (!this.receivedMessages.has(data.body.message.id)) {
+            this.receivedMessages.add(data.body.message.id);
+            if (this.pendingMessageCallback) {
+              this.pendingMessageCallback(result.data);
+            } else {
+              this.pendingMessages.push(result.data);
+            }
+          }
+        }
+      }
+    });
+    this.socket.connect();
+  }
+  onUserMessage(callback) {
+    this.pendingMessageCallback = callback;
+    while (this.pendingMessages.length > 0) {
+      callback(this.pendingMessages.shift());
+    }
+  }
+  /**
+   * Send message to session
+   * @param body - Message body
+   */
+  sendMessage(body) {
+    let content = {
+      role: "agent",
+      content: body
+    };
+    const encrypted = encodeBase64(encrypt(content, this.secret));
+    this.socket.emit("message", {
+      sid: this.sessionId,
+      message: encrypted
+    });
+  }
+  async close() {
+    this.socket.close();
+  }
+}
+
+class ApiClient {
+  token;
+  secret;
+  constructor(token, secret) {
+    this.token = token;
+    this.secret = secret;
+  }
+  /**
+   * Create a new session or load existing one with the given tag
+   */
+  async getOrCreateSession(tag) {
+    try {
+      const response = await axios.post(
+        `https://handy-api.korshakov.org/v1/sessions`,
+        { tag },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger.info(`Session created/loaded: ${response.data.session.id} (tag: ${tag})`);
+      return response.data;
+    } catch (error) {
+      logger.error("Failed to get or create session:", error);
+      throw new Error(`Failed to get or create session: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Start realtime session client
+   * @param id - Session ID
+   * @returns Session client
+   */
+  session(id) {
+    return new ApiSessionClient(this.token, this.secret, id);
+  }
+}
+
+function displayQRCode(url) {
+  try {
+    logger.info("=".repeat(50));
+    logger.info("\u{1F4F1} Scan this QR code with your mobile device:");
+    logger.info("=".repeat(50));
+    qrcode.generate(url, { small: true }, (qr) => {
+      for (let l of qr.split("\n")) {
+        logger.info("         " + l);
+      }
+    });
+    logger.info("=".repeat(50));
+  } catch (error) {
+    logger.error("Failed to generate QR code:", error);
+    logger.info(`\u{1F4CB} Use this URL to connect: ${url}`);
+  }
+}
+
+function claudePath() {
+  if (fs.existsSync(process.env.HOME + "/.claude/local/claude")) {
+    return process.env.HOME + "/.claude/local/claude";
+  } else {
+    return "claude";
+  }
+}
+
+async function* claude(options) {
+  const args = buildArgs(options);
+  const path = claudePath();
+  logger.info("Spawning Claude CLI with args:", args);
+  const process = spawn(path, args, {
+    cwd: options.workingDirectory,
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: false
+  });
+  process.stdin?.end();
+  let outputBuffer = "";
+  let stderrBuffer = "";
+  let processExited = false;
+  const outputQueue = [];
+  let outputResolve = null;
+  process.stdout?.on("data", (data) => {
+    outputBuffer += data.toString();
+    const lines = outputBuffer.split("\n");
+    outputBuffer = lines.pop() || "";
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const json = JSON.parse(line);
+          outputQueue.push({ type: "json", data: json });
+        } catch {
+          outputQueue.push({ type: "text", data: line });
+        }
+        if (outputResolve) {
+          outputResolve();
+          outputResolve = null;
+        }
+      }
+    }
+  });
+  process.stderr?.on("data", (data) => {
+    stderrBuffer += data.toString();
+    const lines = stderrBuffer.split("\n");
+    stderrBuffer = lines.pop() || "";
+    for (const line of lines) {
+      if (line.trim()) {
+        outputQueue.push({ type: "error", error: line });
+        if (outputResolve) {
+          outputResolve();
+          outputResolve = null;
+        }
+      }
+    }
+  });
+  process.on("exit", (code, signal) => {
+    processExited = true;
+    outputQueue.push({ type: "exit", code, signal });
+    if (outputResolve) {
+      outputResolve();
+      outputResolve = null;
+    }
+  });
+  process.on("error", (error) => {
+    outputQueue.push({ type: "error", error: error.message });
+    processExited = true;
+    if (outputResolve) {
+      outputResolve();
+      outputResolve = null;
+    }
+  });
+  while (!processExited || outputQueue.length > 0) {
+    if (outputQueue.length === 0) {
+      await new Promise((resolve) => {
+        outputResolve = resolve;
+        if (outputQueue.length > 0 || processExited) {
+          resolve();
+          outputResolve = null;
+        }
+      });
+    }
+    while (outputQueue.length > 0) {
+      const output = outputQueue.shift();
+      yield output;
+    }
+  }
+  if (outputBuffer.trim()) {
+    try {
+      const json = JSON.parse(outputBuffer);
+      yield { type: "json", data: json };
+    } catch {
+      yield { type: "text", data: outputBuffer };
+    }
+  }
+  if (stderrBuffer.trim()) {
+    yield { type: "error", error: stderrBuffer };
+  }
+}
+function buildArgs(options) {
+  const args = [
+    "--print",
+    options.command,
+    "--output-format",
+    "stream-json",
+    "--verbose"
+  ];
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.permissionMode) {
+    const modeMap = {
+      "auto": "acceptEdits",
+      "default": "default",
+      "plan": "bypassPermissions"
+    };
+    args.push("--permission-mode", modeMap[options.permissionMode]);
+  }
+  if (options.skipPermissions) {
+    args.push("--dangerously-skip-permissions");
+  }
+  if (options.sessionId) {
+    args.push("--resume", options.sessionId);
+  }
+  return args;
+}
+
+function startClaudeLoop(opts, session) {
+  let exiting = false;
+  const messageQueue = [];
+  let messageResolve = null;
+  let promise = (async () => {
+    session.onUserMessage((message) => {
+      messageQueue.push(message);
+      if (messageResolve) {
+        messageResolve();
+        messageResolve = null;
+      }
+    });
+    while (!exiting) {
+      if (messageQueue.length > 0) {
+        const message = messageQueue.shift();
+        if (message) {
+          for await (const output of claude({
+            command: message.content.text,
+            workingDirectory: opts.path,
+            model: opts.model,
+            permissionMode: opts.permissionMode
+          })) {
+            if (output.type === "exit") {
+              if (output.code !== 0 || output.code === void 0) {
+                session.sendMessage({
+                  content: {
+                    type: "error",
+                    error: output.error,
+                    code: output.code
+                  },
+                  role: "assistant"
+                });
+              }
+              break;
+            }
+            if (output.type === "json") {
+              session.sendMessage({
+                data: output.data,
+                type: "output"
+              });
+            }
+          }
+        }
+      }
+      await new Promise((resolve) => {
+        messageResolve = resolve;
+      });
+    }
+  })();
+  return async () => {
+    exiting = true;
+    if (messageResolve) {
+      messageResolve();
+    }
+    await promise;
+  };
+}
+
+async function start(options = {}) {
+  const workingDirectory = process.cwd();
+  const projectName = basename(workingDirectory);
+  const sessionTag = randomUUID();
+  logger.info(`Starting happy session for project: ${projectName}`);
+  const secret = await getOrCreateSecretKey();
+  logger.info("Secret key loaded");
+  const token = await authGetToken(secret);
+  logger.info("Authenticated with handy server");
+  const api = new ApiClient(token, secret);
+  const response = await api.getOrCreateSession(sessionTag);
+  logger.info(`Session created: ${response.session.id}`);
+  const handyUrl = generateAppUrl(secret);
+  displayQRCode(handyUrl);
+  const session = api.session(response.session.id);
+  const loopDestroy = startClaudeLoop({ path: workingDirectory }, session);
+  const shutdown = async () => {
+    logger.info("Shutting down...");
+    await loopDestroy();
+    await session.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  logger.info("Happy CLI is running. Press Ctrl+C to stop.");
+  await new Promise(() => {
+  });
+}
+
+const args = process.argv.slice(2);
+const options = {};
+let showHelp = false;
+let showVersion = false;
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === "-h" || arg === "--help") {
+    showHelp = true;
+  } else if (arg === "-v" || arg === "--version") {
+    showVersion = true;
+  } else if (arg === "-m" || arg === "--model") {
+    options.model = args[++i];
+  } else if (arg === "-p" || arg === "--permission-mode") {
+    options.permissionMode = args[++i];
+  } else {
+    console.error(chalk.red(`Unknown argument: ${arg}`));
+    process.exit(1);
+  }
+}
+if (showHelp) {
+  console.log(`
+${chalk.bold("happy")} - Claude Code session sharing
+
+${chalk.bold("Usage:")}
+  happy [options]
+
+${chalk.bold("Options:")}
+  -h, --help              Show this help message
+  -v, --version           Show version
+  -m, --model <model>     Claude model to use (default: sonnet)
+  -p, --permission-mode   Permission mode: auto, default, or plan
+
+${chalk.bold("Examples:")}
+  happy                   Start a session with default settings
+  happy -m opus           Use Claude Opus model
+  happy -p plan           Use plan permission mode
+`);
+  process.exit(0);
+}
+if (showVersion) {
+  console.log("0.1.0");
+  process.exit(0);
+}
+start(options).catch((error) => {
+  console.error(chalk.red("Error:"), error.message);
+  if (process.env.DEBUG) {
+    console.error(error);
+  }
+  process.exit(1);
+});

package/dist/session/service.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Session service for managing handy-server sessions
+ */
+import type { CreateSessionResponse, GetMessagesResponse, SendMessageResponse } from '#session/types';
+export declare class SessionService {
+    private readonly serverUrl;
+    private readonly authToken;
+    constructor(serverUrl: string, authToken: string);
+    /**
+     * Create a new session or load existing one with the given tag
+     */
+    createSession(tag: string): Promise<CreateSessionResponse>;
+    /**
+     * Decrypt a message content
+     * Note: In real implementation, this would use proper decryption
+     */
+    decryptContent(encryptedContent: string): unknown;
+    /**
+     * Get messages from a session
+     */
+    getMessages(sessionId: string): Promise<GetMessagesResponse>;
+    /**
+     * Send a message to a session
+     * Note: In real implementation, we'd encrypt the content before sending
+     */
+    sendMessage(sessionId: string, content: unknown): Promise<SendMessageResponse>;
+}

package/dist/session/service.js

@@ -0,0 +1,93 @@
+/**
+ * Session service for managing handy-server sessions
+ */
+import { logger } from '#utils/logger';
+import axios from 'axios';
+export class SessionService {
+    serverUrl;
+    authToken;
+    constructor(serverUrl, authToken) {
+        this.serverUrl = serverUrl;
+        this.authToken = authToken;
+    }
+    /**
+     * Create a new session or load existing one with the given tag
+     */
+    async createSession(tag) {
+        try {
+            const response = await axios.post(`${this.serverUrl}/v1/sessions`, { tag }, {
+                headers: {
+                    'Authorization': `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            logger.info(`Session created/loaded: ${response.data.session.id} (tag: ${tag})`);
+            return response.data;
+        }
+        catch (error) {
+            logger.error('Failed to create session:', error);
+            throw new Error(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Decrypt a message content
+     * Note: In real implementation, this would use proper decryption
+     */
+    decryptContent(encryptedContent) {
+        try {
+            const jsonContent = Buffer.from(encryptedContent, 'base64').toString('utf8');
+            return JSON.parse(jsonContent);
+        }
+        catch (error) {
+            logger.error('Failed to decrypt content:', error);
+            throw new Error('Failed to decrypt message content');
+        }
+    }
+    /**
+     * Get messages from a session
+     */
+    async getMessages(sessionId) {
+        try {
+            const response = await axios.get(`${this.serverUrl}/v1/sessions/${sessionId}/messages`, {
+                headers: {
+                    'Authorization': `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            logger.debug(`Retrieved ${response.data.messages.length} messages from session ${sessionId}`);
+            return response.data;
+        }
+        catch (error) {
+            logger.error('Failed to get messages:', error);
+            throw new Error(`Failed to get messages: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Send a message to a session
+     * Note: In real implementation, we'd encrypt the content before sending
+     */
+    async sendMessage(sessionId, content) {
+        try {
+            // For now, we'll just base64 encode the JSON content
+            // In production, this should use proper encryption
+            const jsonContent = JSON.stringify(content);
+            const base64Content = Buffer.from(jsonContent).toString('base64');
+            const messageContent = {
+                c: base64Content,
+                t: 'encrypted'
+            };
+            const response = await axios.post(`${this.serverUrl}/v1/sessions/${sessionId}/messages`, messageContent, {
+                headers: {
+                    'Authorization': `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            logger.debug(`Message sent to session ${sessionId}, seq: ${response.data.message.seq}`);
+            return response.data;
+        }
+        catch (error) {
+            logger.error('Failed to send message:', error);
+            throw new Error(`Failed to send message: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}

package/dist/session/service.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for the session service module
+ *
+ * This test verifies the complete session workflow: create session, send message, read message
+ * using the real handy server API. No mocking is used as per project requirements.
+ */
+export {};