happy-coder 0.10.0-3 → 0.10.0

package/dist/lib.d.mts

@@ -308,11 +308,9 @@ interface RpcRequest {
  * Configuration for RPC handler manager
  */
 interface RpcHandlerConfig {
-    /** Prefix to add to all method names (e.g., sessionId or machineId) */
     scopePrefix: string;
-    /** Secret key for encryption/decryption */
-    secret: Uint8Array;
-    /** Logger function for debugging */
+    encryptionKey: Uint8Array;
+    encryptionVariant: 'legacy' | 'dataKey';
     logger?: (message: string, data?: any) => void;
 }
 
@@ -324,7 +322,8 @@ interface RpcHandlerConfig {
 declare class RpcHandlerManager {
     private handlers;
     private readonly scopePrefix;
-    private readonly secret;
+    private readonly encryptionKey;
+    private readonly encryptionVariant;
     private readonly logger;
     private socket;
     constructor(config: RpcHandlerConfig);
@@ -364,7 +363,6 @@ declare class RpcHandlerManager {
 
 declare class ApiSessionClient extends EventEmitter {
     private readonly token;
-    private readonly secret;
     readonly sessionId: string;
     private metadata;
     private metadataVersion;
@@ -376,7 +374,9 @@ declare class ApiSessionClient extends EventEmitter {
     readonly rpcHandlerManager: RpcHandlerManager;
     private agentStateLock;
     private metadataLock;
-    constructor(token: string, secret: Uint8Array, session: Session);
+    private encryptionKey;
+    private encryptionVariant;
+    constructor(token: string, session: Session);
     onUserMessage(callback: (data: UserMessage) => void): void;
     /**
      * Send message to session
@@ -434,53 +434,16 @@ type Usage = z.infer<typeof UsageSchema>;
 /**
  * Session information
  */
-declare const SessionSchema: z.ZodObject<{
-    createdAt: z.ZodNumber;
-    id: z.ZodString;
-    seq: z.ZodNumber;
-    updatedAt: z.ZodNumber;
-    metadata: z.ZodAny;
-    metadataVersion: z.ZodNumber;
-    agentState: z.ZodNullable<z.ZodAny>;
-    agentStateVersion: z.ZodNumber;
-    connectivityStatus: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["neverConnected", "online", "offline"]>, z.ZodString]>>;
-    connectivityStatusSince: z.ZodOptional<z.ZodNumber>;
-    connectivityStatusReason: z.ZodOptional<z.ZodString>;
-    state: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["running", "archiveRequested", "archived"]>, z.ZodString]>>;
-    stateSince: z.ZodOptional<z.ZodNumber>;
-    stateReason: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    seq: number;
-    createdAt: number;
-    updatedAt: number;
-    metadataVersion: number;
-    agentStateVersion: number;
-    metadata?: any;
-    agentState?: any;
-    connectivityStatus?: string | undefined;
-    connectivityStatusSince?: number | undefined;
-    connectivityStatusReason?: string | undefined;
-    state?: string | undefined;
-    stateSince?: number | undefined;
-    stateReason?: string | undefined;
-}, {
+type Session = {
     id: string;
     seq: number;
-    createdAt: number;
-    updatedAt: number;
+    encryptionKey: Uint8Array;
+    encryptionVariant: 'legacy' | 'dataKey';
+    metadata: Metadata;
     metadataVersion: number;
+    agentState: AgentState | null;
     agentStateVersion: number;
-    metadata?: any;
-    agentState?: any;
-    connectivityStatus?: string | undefined;
-    connectivityStatusSince?: number | undefined;
-    connectivityStatusReason?: string | undefined;
-    state?: string | undefined;
-    stateSince?: number | undefined;
-    stateReason?: string | undefined;
-}>;
-type Session = z.infer<typeof SessionSchema>;
+};
 /**
  * Machine metadata - static information (rarely changes)
  */
@@ -533,59 +496,15 @@ declare const DaemonStateSchema: z.ZodObject<{
     shutdownSource?: string | undefined;
 }>;
 type DaemonState = z.infer<typeof DaemonStateSchema>;
-/**
- * Machine information - similar to Session
- */
-declare const MachineSchema: z.ZodObject<{
-    id: z.ZodString;
-    metadata: z.ZodAny;
-    metadataVersion: z.ZodNumber;
-    daemonState: z.ZodNullable<z.ZodAny>;
-    daemonStateVersion: z.ZodNumber;
-    active: z.ZodBoolean;
-    activeAt: z.ZodNumber;
-    createdAt: z.ZodNumber;
-    updatedAt: z.ZodNumber;
-    connectivityStatus: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["neverConnected", "online", "offline"]>, z.ZodString]>>;
-    connectivityStatusSince: z.ZodOptional<z.ZodNumber>;
-    connectivityStatusReason: z.ZodOptional<z.ZodString>;
-    state: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["running", "archiveRequested", "archived"]>, z.ZodString]>>;
-    stateSince: z.ZodOptional<z.ZodNumber>;
-    stateReason: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    createdAt: number;
-    updatedAt: number;
-    metadataVersion: number;
-    daemonStateVersion: number;
-    active: boolean;
-    activeAt: number;
-    metadata?: any;
-    daemonState?: any;
-    connectivityStatus?: string | undefined;
-    connectivityStatusSince?: number | undefined;
-    connectivityStatusReason?: string | undefined;
-    state?: string | undefined;
-    stateSince?: number | undefined;
-    stateReason?: string | undefined;
-}, {
+type Machine = {
     id: string;
-    createdAt: number;
-    updatedAt: number;
+    encryptionKey: Uint8Array;
+    encryptionVariant: 'legacy' | 'dataKey';
+    metadata: MachineMetadata;
     metadataVersion: number;
+    daemonState: DaemonState | null;
     daemonStateVersion: number;
-    active: boolean;
-    activeAt: number;
-    metadata?: any;
-    daemonState?: any;
-    connectivityStatus?: string | undefined;
-    connectivityStatusSince?: number | undefined;
-    connectivityStatusReason?: string | undefined;
-    state?: string | undefined;
-    stateSince?: number | undefined;
-    stateReason?: string | undefined;
-}>;
-type Machine = z.infer<typeof MachineSchema>;
+};
 declare const UserMessageSchema: z.ZodObject<{
     role: z.ZodLiteral<"user">;
     content: z.ZodObject<{
@@ -719,6 +638,8 @@ interface SpawnSessionOptions {
     directory: string;
     sessionId?: string;
     approvedNewDirectoryCreation?: boolean;
+    agent?: 'claude' | 'codex';
+    token?: string;
 }
 type SpawnSessionResult = {
     type: 'success';
@@ -743,12 +664,11 @@ type MachineRpcHandlers = {
 };
 declare class ApiMachineClient {
     private token;
-    private secret;
     private machine;
     private socket;
     private keepAliveInterval;
     private rpcHandlerManager;
-    constructor(token: string, secret: Uint8Array, machine: Machine);
+    constructor(token: string, machine: Machine);
     setRPCHandlers({ spawnSession, stopSession, requestShutdown }: MachineRpcHandlers): void;
     /**
      * Update machine metadata
@@ -796,11 +716,29 @@ declare class PushNotificationClient {
     sendToAllDevices(title: string, body: string, data?: Record<string, any>): void;
 }
 
+/**
+ * Minimal persistence functions for happy CLI
+ *
+ * Handles settings and private key storage in ~/.happy/ or local .happy/
+ */
+
+type Credentials = {
+    token: string;
+    encryption: {
+        type: 'legacy';
+        secret: Uint8Array;
+    } | {
+        type: 'dataKey';
+        publicKey: Uint8Array;
+        machineKey: Uint8Array;
+    };
+};
+
 declare class ApiClient {
-    private readonly token;
-    private readonly secret;
+    static create(credential: Credentials): Promise<ApiClient>;
+    private readonly credential;
     private readonly pushClient;
-    constructor(token: string, secret: Uint8Array);
+    private constructor();
     /**
      * Create a new session or load existing one with the given tag
      */
@@ -809,11 +747,6 @@ declare class ApiClient {
         metadata: Metadata;
         state: AgentState | null;
     }): Promise<Session>;
-    /**
-     * Get machine by ID from the server
-     * Returns the current machine state from the server with decrypted metadata and daemonState
-     */
-    getMachine(machineId: string): Promise<Machine | null>;
     /**
      * Register or update machine with the server
      * Returns the current machine state from the server with decrypted metadata and daemonState
@@ -864,6 +797,7 @@ declare let logger: Logger;
  */
 declare class Configuration {
     readonly serverUrl: string;
+    readonly webappUrl: string;
     readonly isDaemonProcess: boolean;
     readonly happyHomeDir: string;
     readonly logsDir: string;

package/dist/lib.mjs

@@ -1,4 +1,4 @@
-export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-xds_c-JJ.mjs';
+export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-8Ad05p3x.mjs';
 import 'axios';
 import 'chalk';
 import 'fs';

package/dist/{runCodex-C07HQlsW.mjs → runCodex-HlLNepHI.mjs}

@@ -1,12 +1,12 @@
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
-import { l as logger, A as ApiClient, r as readSettings, p as projectPath, c as configuration, b as packageJson } from './types-xds_c-JJ.mjs';
+import { l as logger, A as ApiClient, r as readSettings, p as projectPath, c as configuration, b as packageJson } from './types-8Ad05p3x.mjs';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { z } from 'zod';
 import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { randomUUID } from 'node:crypto';
-import { i as initialMachineMetadata, M as MessageQueue2, h as hashObject, a as MessageBuffer, s as startHappyServer, t as trimIdent } from './index-DPVbp4Yx.mjs';
+import { i as initialMachineMetadata, n as notifyDaemonSessionStarted, M as MessageQueue2, h as hashObject, r as registerKillSessionHandler, a as MessageBuffer, s as startHappyServer, t as trimIdent, b as stopCaffeinate } from './index-BI37NnoW.mjs';
 import os from 'node:os';
 import { resolve, join } from 'node:path';
 import fs from 'node:fs';
@@ -30,6 +30,7 @@ import 'node:readline';
 import 'node:url';
 import 'ps-list';
 import 'cross-spawn';
+import 'tmp';
 import 'qrcode-terminal';
 import 'open';
 import 'fastify';
@@ -678,7 +679,8 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
 
 async function runCodex(opts) {
   const sessionTag = randomUUID();
-  const api = new ApiClient(opts.token, opts.secret);
+  const api = await ApiClient.create(opts.credentials);
+  logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}`);
   const settings = await readSettings();
   let machineId = settings?.machineId;
   if (!machineId) {
@@ -703,9 +705,9 @@ async function runCodex(opts) {
     happyHomeDir: configuration.happyHomeDir,
     happyLibDir: projectPath(),
     happyToolsDir: resolve(projectPath(), "tools", "unpacked"),
-    startedFromDaemon: false,
+    startedFromDaemon: opts.startedBy === "daemon",
     hostPid: process.pid,
-    startedBy: "terminal",
+    startedBy: opts.startedBy || "terminal",
     // Initialize lifecycle state
     lifecycleState: "running",
     lifecycleStateSince: Date.now(),
@@ -713,6 +715,17 @@ async function runCodex(opts) {
   };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   const session = api.sessionSyncClient(response);
+  try {
+    logger.debug(`[START] Reporting session ${response.id} to daemon`);
+    const result = await notifyDaemonSessionStarted(response.id, metadata);
+    if (result.error) {
+      logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
+    } else {
+      logger.debug(`[START] Reported session ${response.id} to daemon`);
+    }
+  } catch (error) {
+    logger.debug("[START] Failed to report to daemon (may not be running):", error);
+  }
   const messageQueue = new MessageQueue2((mode) => hashObject({
     permissionMode: mode.permissionMode,
     model: mode.model
@@ -781,7 +794,34 @@ async function runCodex(opts) {
       abortController = new AbortController();
     }
   }
+  const cleanup = async () => {
+    logger.debug("[Codex] Cleanup start");
+    await handleAbort();
+    logger.debug("[Codex] Cleanup completed");
+    try {
+      if (session) {
+        session.updateMetadata((currentMetadata) => ({
+          ...currentMetadata,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: "cli",
+          archiveReason: "User terminated"
+        }));
+        session.sendSessionDeath();
+        await session.flush();
+        await session.close();
+      }
+      stopCaffeinate();
+      happyServer.stop();
+      logger.debug("[Codex] Cleanup complete, exiting");
+      process.exit(0);
+    } catch (error) {
+      logger.debug("[Codex] Error during cleanup:", error);
+      process.exit(1);
+    }
+  };
   session.rpcHandlerManager.registerHandler("abort", handleAbort);
+  registerKillSessionHandler(session.rpcHandlerManager, cleanup);
   const messageBuffer = new MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   let inkInstance = null;
@@ -829,7 +869,8 @@ async function runCodex(opts) {
         return acc;
       };
       var collectFilesRecursive = collectFilesRecursive2;
-      const rootDir = join(os.homedir(), ".codex", "sessions");
+      const codexHomeDir = process.env.CODEX_HOME || join(os.homedir(), ".codex");
+      const rootDir = join(codexHomeDir, "sessions");
       const candidates = collectFilesRecursive2(rootDir).filter((full) => full.endsWith(`-${sessionId}.jsonl`)).filter((full) => {
         try {
           return fs.statSync(full).isFile();

package/dist/{runCodex-BxLD6H6G.cjs → runCodex-QdQBx9HK.cjs}

@@ -2,13 +2,13 @@
 
 var ink = require('ink');
 var React = require('react');
-var types = require('./types-CsJGQvQ3.cjs');
+var types = require('./types-CQOz_mPp.cjs');
 var index_js = require('@modelcontextprotocol/sdk/client/index.js');
 var stdio_js = require('@modelcontextprotocol/sdk/client/stdio.js');
 var z = require('zod');
 var types_js = require('@modelcontextprotocol/sdk/types.js');
 var node_crypto = require('node:crypto');
-var index = require('./index-tqOLc1Il.cjs');
+var index = require('./index-ettJex_e.cjs');
 var os = require('node:os');
 var node_path = require('node:path');
 var fs = require('node:fs');
@@ -32,6 +32,7 @@ require('node:readline');
 require('node:url');
 require('ps-list');
 require('cross-spawn');
+require('tmp');
 require('qrcode-terminal');
 require('open');
 require('fastify');
@@ -680,7 +681,8 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
 
 async function runCodex(opts) {
   const sessionTag = node_crypto.randomUUID();
-  const api = new types.ApiClient(opts.token, opts.secret);
+  const api = await types.ApiClient.create(opts.credentials);
+  types.logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}`);
   const settings = await types.readSettings();
   let machineId = settings?.machineId;
   if (!machineId) {
@@ -705,9 +707,9 @@ async function runCodex(opts) {
     happyHomeDir: types.configuration.happyHomeDir,
     happyLibDir: types.projectPath(),
     happyToolsDir: node_path.resolve(types.projectPath(), "tools", "unpacked"),
-    startedFromDaemon: false,
+    startedFromDaemon: opts.startedBy === "daemon",
     hostPid: process.pid,
-    startedBy: "terminal",
+    startedBy: opts.startedBy || "terminal",
     // Initialize lifecycle state
     lifecycleState: "running",
     lifecycleStateSince: Date.now(),
@@ -715,6 +717,17 @@ async function runCodex(opts) {
   };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   const session = api.sessionSyncClient(response);
+  try {
+    types.logger.debug(`[START] Reporting session ${response.id} to daemon`);
+    const result = await index.notifyDaemonSessionStarted(response.id, metadata);
+    if (result.error) {
+      types.logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
+    } else {
+      types.logger.debug(`[START] Reported session ${response.id} to daemon`);
+    }
+  } catch (error) {
+    types.logger.debug("[START] Failed to report to daemon (may not be running):", error);
+  }
   const messageQueue = new index.MessageQueue2((mode) => index.hashObject({
     permissionMode: mode.permissionMode,
     model: mode.model
@@ -783,7 +796,34 @@ async function runCodex(opts) {
       abortController = new AbortController();
     }
   }
+  const cleanup = async () => {
+    types.logger.debug("[Codex] Cleanup start");
+    await handleAbort();
+    types.logger.debug("[Codex] Cleanup completed");
+    try {
+      if (session) {
+        session.updateMetadata((currentMetadata) => ({
+          ...currentMetadata,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: "cli",
+          archiveReason: "User terminated"
+        }));
+        session.sendSessionDeath();
+        await session.flush();
+        await session.close();
+      }
+      index.stopCaffeinate();
+      happyServer.stop();
+      types.logger.debug("[Codex] Cleanup complete, exiting");
+      process.exit(0);
+    } catch (error) {
+      types.logger.debug("[Codex] Error during cleanup:", error);
+      process.exit(1);
+    }
+  };
   session.rpcHandlerManager.registerHandler("abort", handleAbort);
+  index.registerKillSessionHandler(session.rpcHandlerManager, cleanup);
   const messageBuffer = new index.MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   let inkInstance = null;
@@ -831,7 +871,8 @@ async function runCodex(opts) {
         return acc;
       };
       var collectFilesRecursive = collectFilesRecursive2;
-      const rootDir = node_path.join(os.homedir(), ".codex", "sessions");
+      const codexHomeDir = process.env.CODEX_HOME || node_path.join(os.homedir(), ".codex");
+      const rootDir = node_path.join(codexHomeDir, "sessions");
       const candidates = collectFilesRecursive2(rootDir).filter((full) => full.endsWith(`-${sessionId}.jsonl`)).filter((full) => {
         try {
           return fs.statSync(full).isFile();