happy-coder 0.9.0-6 → 0.9.0

package/dist/{types-DJOX-XG-.mjs → types-Cezp_n6O.mjs}

@@ -1,27 +1,156 @@
 import axios from 'axios';
 import chalk from 'chalk';
 import { appendFileSync } from 'fs';
+import { existsSync, mkdirSync, constants, readFileSync, unlinkSync, writeFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { mkdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { EventEmitter } from 'node:events';
-import { io } from 'socket.io-client';
-import { z } from 'zod';
+import { join, basename } from 'node:path';
+import { readFile, open, stat, unlink, mkdir, writeFile, rename } from 'node:fs/promises';
+import * as z from 'zod';
+import { z as z$1 } from 'zod';
 import { randomBytes, randomUUID } from 'node:crypto';
 import tweetnacl from 'tweetnacl';
+import { EventEmitter } from 'node:events';
+import { io } from 'socket.io-client';
 import { Expo } from 'expo-server-sdk';
 
+var name = "happy-coder";
+var version = "0.9.0";
+var description = "Claude Code session sharing CLI";
+var author = "Kirill Dubovitskiy";
+var license = "MIT";
+var type = "module";
+var homepage = "https://github.com/slopus/happy-cli";
+var bugs = "https://github.com/slopus/happy-cli/issues";
+var repository = "slopus/happy-cli";
+var bin = {
+	happy: "./bin/happy.mjs"
+};
+var main = "./dist/index.cjs";
+var module = "./dist/index.mjs";
+var types = "./dist/index.d.cts";
+var exports = {
+	".": {
+		require: {
+			types: "./dist/index.d.cts",
+			"default": "./dist/index.cjs"
+		},
+		"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"
+		}
+	}
+};
+var files = [
+	"dist",
+	"bin",
+	"scripts",
+	"ripgrep",
+	"package.json"
+];
+var scripts = {
+	"why do we need to build before running tests / dev?": "We need the binary to be built so we run daemon commands which directly run the binary - we don't want them to go out of sync or have custom spawn logic depending how we started happy",
+	typecheck: "tsc --noEmit",
+	build: "shx rm -rf dist && npx tsc --noEmit && pkgroll",
+	test: "yarn build && tsx --env-file .env.integration-test node_modules/.bin/vitest run",
+	start: "yarn build && ./bin/happy.mjs",
+	dev: "yarn build && tsx --env-file .env.dev src/index.ts",
+	"dev:local-server": "yarn build && tsx --env-file .env.dev-local-server src/index.ts",
+	"dev:integration-test-env": "yarn build && tsx --env-file .env.integration-test src/index.ts",
+	prepublishOnly: "yarn build && yarn test",
+	release: "release-it"
+};
+var dependencies = {
+	"@anthropic-ai/claude-code": "^1.0.89",
+	"@anthropic-ai/sdk": "^0.56.0",
+	"@modelcontextprotocol/sdk": "^1.15.1",
+	"@stablelib/base64": "^2.0.1",
+	"@types/http-proxy": "^1.17.16",
+	"@types/qrcode-terminal": "^0.12.2",
+	"@types/react": "^19.1.9",
+	axios: "^1.10.0",
+	chalk: "^5.4.1",
+	"expo-server-sdk": "^3.15.0",
+	fastify: "^5.5.0",
+	"fastify-type-provider-zod": "4.0.2",
+	"http-proxy": "^1.18.1",
+	"http-proxy-middleware": "^3.0.5",
+	ink: "^6.1.0",
+	open: "^10.2.0",
+	"qrcode-terminal": "^0.12.0",
+	react: "^19.1.1",
+	"socket.io-client": "^4.8.1",
+	tweetnacl: "^1.0.3",
+	zod: "^3.23.8"
+};
+var devDependencies = {
+	"@eslint/compat": "^1",
+	"@types/node": ">=20",
+	"cross-env": "^10.0.0",
+	dotenv: "^16.6.1",
+	eslint: "^9",
+	"eslint-config-prettier": "^10",
+	pkgroll: "^2.14.2",
+	"release-it": "^19.0.4",
+	shx: "^0.3.3",
+	"ts-node": "^10",
+	tsx: "^4.20.3",
+	typescript: "^5",
+	vitest: "^3.2.4"
+};
+var resolutions = {
+	"whatwg-url": "14.2.0",
+	"parse-path": "7.0.3",
+	"@types/parse-path": "7.0.3"
+};
+var publishConfig = {
+	registry: "https://registry.npmjs.org"
+};
+var packageManager = "yarn@1.22.22";
+var packageJson = {
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	license: license,
+	type: type,
+	homepage: homepage,
+	bugs: bugs,
+	repository: repository,
+	bin: bin,
+	main: main,
+	module: module,
+	types: types,
+	exports: exports,
+	files: files,
+	scripts: scripts,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	resolutions: resolutions,
+	publishConfig: publishConfig,
+	packageManager: packageManager
+};
+
 class Configuration {
   serverUrl;
   isDaemonProcess;
   // Directories and paths (from persistence)
   happyHomeDir;
   logsDir;
-  daemonLogsDir;
   settingsFile;
   privateKeyFile;
   daemonStateFile;
+  daemonLockFile;
+  currentCliVersion;
   isExperimentalEnabled;
   constructor() {
     this.serverUrl = process.env.HAPPY_SERVER_URL || "https://handy-api.korshakov.org";
@@ -34,15 +163,231 @@ class Configuration {
       this.happyHomeDir = join(homedir(), ".happy");
     }
     this.logsDir = join(this.happyHomeDir, "logs");
-    this.daemonLogsDir = join(this.happyHomeDir, "logs-daemon");
     this.settingsFile = join(this.happyHomeDir, "settings.json");
     this.privateKeyFile = join(this.happyHomeDir, "access.key");
     this.daemonStateFile = join(this.happyHomeDir, "daemon.state.json");
+    this.daemonLockFile = join(this.happyHomeDir, "daemon.state.json.lock");
     this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.HAPPY_EXPERIMENTAL?.toLowerCase() || "");
+    this.currentCliVersion = packageJson.version;
+    if (!existsSync(this.happyHomeDir)) {
+      mkdirSync(this.happyHomeDir, { recursive: true });
+    }
+    if (!existsSync(this.logsDir)) {
+      mkdirSync(this.logsDir, { recursive: true });
+    }
   }
 }
 const configuration = new Configuration();
 
+function encodeBase64(buffer, variant = "base64") {
+  if (variant === "base64url") {
+    return encodeBase64Url(buffer);
+  }
+  return Buffer.from(buffer).toString("base64");
+}
+function encodeBase64Url(buffer) {
+  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64(base64, variant = "base64") {
+  if (variant === "base64url") {
+    const base64Standard = base64.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - base64.length % 4) % 4);
+    return new Uint8Array(Buffer.from(base64Standard, "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));
+}
+
+const defaultSettings = {
+  onboardingCompleted: false
+};
+async function readSettings() {
+  if (!existsSync(configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await readFile(configuration.settingsFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { ...defaultSettings };
+  }
+}
+async function updateSettings(updater) {
+  const LOCK_RETRY_INTERVAL_MS = 100;
+  const MAX_LOCK_ATTEMPTS = 50;
+  const STALE_LOCK_TIMEOUT_MS = 1e4;
+  const lockFile = configuration.settingsFile + ".lock";
+  const tmpFile = configuration.settingsFile + ".tmp";
+  let fileHandle;
+  let attempts = 0;
+  while (attempts < MAX_LOCK_ATTEMPTS) {
+    try {
+      fileHandle = await open(lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        attempts++;
+        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
+        try {
+          const stats = await stat(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await unlink(lockFile).catch(() => {
+            });
+          }
+        } catch {
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!fileHandle) {
+    throw new Error(`Failed to acquire settings lock after ${MAX_LOCK_ATTEMPTS * LOCK_RETRY_INTERVAL_MS / 1e3} seconds`);
+  }
+  try {
+    const current = await readSettings() || { ...defaultSettings };
+    const updated = await updater(current);
+    if (!existsSync(configuration.happyHomeDir)) {
+      await mkdir(configuration.happyHomeDir, { recursive: true });
+    }
+    await writeFile(tmpFile, JSON.stringify(updated, null, 2));
+    await rename(tmpFile, configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z.object({
+  secret: z.string().base64(),
+  token: z.string()
+});
+async function readCredentials() {
+  if (!existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await readFile(configuration.privateKeyFile, "utf8");
+    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
+    return {
+      secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
+      token: credentials.token
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCredentials(credentials) {
+  if (!existsSync(configuration.happyHomeDir)) {
+    await mkdir(configuration.happyHomeDir, { recursive: true });
+  }
+  await writeFile(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token
+  }, null, 2));
+}
+async function clearCredentials() {
+  if (existsSync(configuration.privateKeyFile)) {
+    await unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!existsSync(configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await readFile(configuration.daemonStateFile, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`[PERSISTENCE] Daemon state file corrupted: ${configuration.daemonStateFile}`, error);
+    return null;
+  }
+}
+function writeDaemonState(state) {
+  writeFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2), "utf-8");
+}
+async function clearDaemonState() {
+  if (existsSync(configuration.daemonStateFile)) {
+    await unlink(configuration.daemonStateFile);
+  }
+  if (existsSync(configuration.daemonLockFile)) {
+    try {
+      await unlink(configuration.daemonLockFile);
+    } catch {
+    }
+  }
+}
+async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const fileHandle = await open(
+        configuration.daemonLockFile,
+        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = readFileSync(configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              unlinkSync(configuration.daemonLockFile);
+              continue;
+            }
+          }
+        } catch {
+        }
+      }
+      if (attempt === maxAttempts) {
+        return null;
+      }
+      const delayMs = attempt * delayIncrementMs;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return null;
+}
+async function releaseDaemonLock(lockHandle) {
+  try {
+    await lockHandle.close();
+  } catch {
+  }
+  try {
+    if (existsSync(configuration.daemonLockFile)) {
+      unlinkSync(configuration.daemonLockFile);
+    }
+  } catch {
+  }
+}
+
 function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
   return date.toLocaleString("sv-SE", {
     timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
@@ -52,7 +397,7 @@ function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
     hour: "2-digit",
     minute: "2-digit",
     second: "2-digit"
-  }).replace(/[: ]/g, "-").replace(/,/g, "");
+  }).replace(/[: ]/g, "-").replace(/,/g, "") + "-pid-" + process.pid;
 }
 function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
   return date.toLocaleTimeString("en-US", {
@@ -64,17 +409,14 @@ function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
     fractionalSecondDigits: 3
   });
 }
-async function getSessionLogPath() {
-  if (!existsSync(configuration.logsDir)) {
-    await mkdir(configuration.logsDir, { recursive: true });
-  }
+function getSessionLogPath() {
   const timestamp = createTimestampForFilename();
   const filename = configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
   return join(configuration.logsDir, filename);
 }
 class Logger {
-  constructor(logFilePathPromise = getSessionLogPath()) {
-    this.logFilePathPromise = logFilePathPromise;
+  constructor(logFilePath = getSessionLogPath()) {
+    this.logFilePath = logFilePath;
     if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && process.env.HAPPY_SERVER_URL) {
       this.dangerouslyUnencryptedServerLoggingUrl = process.env.HAPPY_SERVER_URL;
       console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
@@ -187,218 +529,214 @@ class Logger {
       this.sendToRemoteServer(level, message, ...args).catch(() => {
       });
     }
-    this.logFilePathPromise.then((logFilePath) => {
-      try {
-        appendFileSync(logFilePath, logLine);
-      } catch (appendError) {
-        if (process.env.DEBUG) {
-          console.error("Failed to append to log file:", appendError);
-          throw appendError;
-        }
-      }
-    }).catch((error) => {
+    try {
+      appendFileSync(this.logFilePath, logLine);
+    } catch (appendError) {
       if (process.env.DEBUG) {
-        console.log("This message only visible in DEBUG mode, not in production");
-        console.error("Failed to resolve log file path:", error);
-        console.log(prefix, message, ...args);
+        console.error("Failed to append to log file:", appendError);
+        throw appendError;
       }
-    });
+    }
   }
 }
 let logger = new Logger();
+async function listDaemonLogFiles(limit = 50) {
+  try {
+    const logsDir = configuration.logsDir;
+    if (!existsSync(logsDir)) {
+      return [];
+    }
+    const logs = readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
+      const fullPath = join(logsDir, file);
+      const stats = statSync(fullPath);
+      return { file, path: fullPath, modified: stats.mtime };
+    }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    try {
+      const state = await readDaemonState();
+      if (!state) {
+        return logs;
+      }
+      if (state.daemonLogPath && existsSync(state.daemonLogPath)) {
+        const stats = statSync(state.daemonLogPath);
+        const persisted = {
+          file: basename(state.daemonLogPath),
+          path: state.daemonLogPath,
+          modified: stats.mtime
+        };
+        const idx = logs.findIndex((l) => l.path === persisted.path);
+        if (idx >= 0) {
+          const [found] = logs.splice(idx, 1);
+          logs.unshift(found);
+        } else {
+          logs.unshift(persisted);
+        }
+      }
+    } catch {
+    }
+    return logs.slice(0, Math.max(0, limit));
+  } catch {
+    return [];
+  }
+}
+async function getLatestDaemonLog() {
+  const [latest] = await listDaemonLogFiles(1);
+  return latest || null;
+}
 
-const SessionMessageContentSchema = z.object({
-  c: z.string(),
+const SessionMessageContentSchema = z$1.object({
+  c: z$1.string(),
   // Base64 encoded encrypted content
-  t: z.literal("encrypted")
+  t: z$1.literal("encrypted")
 });
-const UpdateBodySchema = z.object({
-  message: z.object({
-    id: z.string(),
-    seq: z.number(),
+const UpdateBodySchema = z$1.object({
+  message: z$1.object({
+    id: z$1.string(),
+    seq: z$1.number(),
     content: SessionMessageContentSchema
   }),
-  sid: z.string(),
+  sid: z$1.string(),
   // Session ID
-  t: z.literal("new-message")
+  t: z$1.literal("new-message")
 });
-const UpdateSessionBodySchema = z.object({
-  t: z.literal("update-session"),
-  sid: z.string(),
-  metadata: z.object({
-    version: z.number(),
-    value: z.string()
+const UpdateSessionBodySchema = z$1.object({
+  t: z$1.literal("update-session"),
+  sid: z$1.string(),
+  metadata: z$1.object({
+    version: z$1.number(),
+    value: z$1.string()
   }).nullish(),
-  agentState: z.object({
-    version: z.number(),
-    value: z.string()
+  agentState: z$1.object({
+    version: z$1.number(),
+    value: z$1.string()
   }).nullish()
 });
-const UpdateMachineBodySchema = z.object({
-  t: z.literal("update-machine"),
-  machineId: z.string(),
-  metadata: z.object({
-    version: z.number(),
-    value: z.string()
+const UpdateMachineBodySchema = z$1.object({
+  t: z$1.literal("update-machine"),
+  machineId: z$1.string(),
+  metadata: z$1.object({
+    version: z$1.number(),
+    value: z$1.string()
   }).nullish(),
-  daemonState: z.object({
-    version: z.number(),
-    value: z.string()
+  daemonState: z$1.object({
+    version: z$1.number(),
+    value: z$1.string()
   }).nullish()
 });
-z.object({
-  id: z.string(),
-  seq: z.number(),
-  body: z.union([
+z$1.object({
+  id: z$1.string(),
+  seq: z$1.number(),
+  body: z$1.union([
     UpdateBodySchema,
     UpdateSessionBodySchema,
     UpdateMachineBodySchema
   ]),
-  createdAt: z.number()
+  createdAt: z$1.number()
 });
-z.object({
-  createdAt: z.number(),
-  id: z.string(),
-  seq: z.number(),
-  updatedAt: z.number(),
-  metadata: z.any(),
-  metadataVersion: z.number(),
-  agentState: z.any().nullable(),
-  agentStateVersion: z.number()
+z$1.object({
+  createdAt: z$1.number(),
+  id: z$1.string(),
+  seq: z$1.number(),
+  updatedAt: z$1.number(),
+  metadata: z$1.any(),
+  metadataVersion: z$1.number(),
+  agentState: z$1.any().nullable(),
+  agentStateVersion: z$1.number()
 });
-z.object({
-  host: z.string(),
-  platform: z.string(),
-  happyCliVersion: z.string(),
-  homeDir: z.string(),
-  happyHomeDir: z.string()
+z$1.object({
+  host: z$1.string(),
+  platform: z$1.string(),
+  happyCliVersion: z$1.string(),
+  homeDir: z$1.string(),
+  happyHomeDir: z$1.string()
 });
-z.object({
-  status: z.union([
-    z.enum(["running", "shutting-down"]),
-    z.string()
+z$1.object({
+  status: z$1.union([
+    z$1.enum(["running", "shutting-down"]),
+    z$1.string()
     // Forward compatibility
   ]),
-  pid: z.number().optional(),
-  httpPort: z.number().optional(),
-  startedAt: z.number().optional(),
-  shutdownRequestedAt: z.number().optional(),
-  shutdownSource: z.union([
-    z.enum(["mobile-app", "cli", "os-signal", "unknown"]),
-    z.string()
+  pid: z$1.number().optional(),
+  httpPort: z$1.number().optional(),
+  startedAt: z$1.number().optional(),
+  shutdownRequestedAt: z$1.number().optional(),
+  shutdownSource: z$1.union([
+    z$1.enum(["mobile-app", "cli", "os-signal", "unknown"]),
+    z$1.string()
     // Forward compatibility
   ]).optional()
 });
-z.object({
-  id: z.string(),
-  metadata: z.any(),
+z$1.object({
+  id: z$1.string(),
+  metadata: z$1.any(),
   // Decrypted MachineMetadata
-  metadataVersion: z.number(),
-  daemonState: z.any().nullable(),
+  metadataVersion: z$1.number(),
+  daemonState: z$1.any().nullable(),
   // Decrypted DaemonState
-  daemonStateVersion: z.number(),
+  daemonStateVersion: z$1.number(),
   // We don't really care about these on the CLI for now
   // ApiMachineClient will not sync these
-  active: z.boolean(),
-  activeAt: z.number(),
-  createdAt: z.number(),
-  updatedAt: z.number()
+  active: z$1.boolean(),
+  activeAt: z$1.number(),
+  createdAt: z$1.number(),
+  updatedAt: z$1.number()
 });
-z.object({
+z$1.object({
   content: SessionMessageContentSchema,
-  createdAt: z.number(),
-  id: z.string(),
-  seq: z.number(),
-  updatedAt: z.number()
+  createdAt: z$1.number(),
+  id: z$1.string(),
+  seq: z$1.number(),
+  updatedAt: z$1.number()
 });
-const MessageMetaSchema = z.object({
-  sentFrom: z.string().optional(),
+const MessageMetaSchema = z$1.object({
+  sentFrom: z$1.string().optional(),
   // Source identifier
-  permissionMode: z.string().optional(),
+  permissionMode: z$1.string().optional(),
   // Permission mode for this message
-  model: z.string().nullable().optional(),
+  model: z$1.string().nullable().optional(),
   // Model name for this message (null = reset)
-  fallbackModel: z.string().nullable().optional(),
+  fallbackModel: z$1.string().nullable().optional(),
   // Fallback model for this message (null = reset)
-  customSystemPrompt: z.string().nullable().optional(),
+  customSystemPrompt: z$1.string().nullable().optional(),
   // Custom system prompt for this message (null = reset)
-  appendSystemPrompt: z.string().nullable().optional(),
+  appendSystemPrompt: z$1.string().nullable().optional(),
   // Append to system prompt for this message (null = reset)
-  allowedTools: z.array(z.string()).nullable().optional(),
+  allowedTools: z$1.array(z$1.string()).nullable().optional(),
   // Allowed tools for this message (null = reset)
-  disallowedTools: z.array(z.string()).nullable().optional()
+  disallowedTools: z$1.array(z$1.string()).nullable().optional()
   // Disallowed tools for this message (null = reset)
 });
-z.object({
-  session: z.object({
-    id: z.string(),
-    tag: z.string(),
-    seq: z.number(),
-    createdAt: z.number(),
-    updatedAt: z.number(),
-    metadata: z.string(),
-    metadataVersion: z.number(),
-    agentState: z.string().nullable(),
-    agentStateVersion: z.number()
+z$1.object({
+  session: z$1.object({
+    id: z$1.string(),
+    tag: z$1.string(),
+    seq: z$1.number(),
+    createdAt: z$1.number(),
+    updatedAt: z$1.number(),
+    metadata: z$1.string(),
+    metadataVersion: z$1.number(),
+    agentState: z$1.string().nullable(),
+    agentStateVersion: z$1.number()
   })
 });
-const UserMessageSchema = z.object({
-  role: z.literal("user"),
-  content: z.object({
-    type: z.literal("text"),
-    text: z.string()
+const UserMessageSchema = z$1.object({
+  role: z$1.literal("user"),
+  content: z$1.object({
+    type: z$1.literal("text"),
+    text: z$1.string()
   }),
-  localKey: z.string().optional(),
+  localKey: z$1.string().optional(),
   // Mobile messages include this
   meta: MessageMetaSchema.optional()
 });
-const AgentMessageSchema = z.object({
-  role: z.literal("agent"),
-  content: z.object({
-    type: z.literal("output"),
-    data: z.any()
+const AgentMessageSchema = z$1.object({
+  role: z$1.literal("agent"),
+  content: z$1.object({
+    type: z$1.literal("output"),
+    data: z$1.any()
   }),
   meta: MessageMetaSchema.optional()
 });
-z.union([UserMessageSchema, AgentMessageSchema]);
-
-function encodeBase64(buffer, variant = "base64") {
-  if (variant === "base64url") {
-    return encodeBase64Url(buffer);
-  }
-  return Buffer.from(buffer).toString("base64");
-}
-function encodeBase64Url(buffer) {
-  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
-}
-function decodeBase64(base64, variant = "base64") {
-  if (variant === "base64url") {
-    const base64Standard = base64.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - base64.length % 4) % 4);
-    return new Uint8Array(Buffer.from(base64Standard, "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) {
-    logger.debug("[ERROR] Decryption failed");
-    return null;
-  }
-  return JSON.parse(new TextDecoder().decode(decrypted));
-}
+z$1.union([UserMessageSchema, AgentMessageSchema]);
 
 async function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -653,6 +991,7 @@ class ApiSessionClient extends EventEmitter {
    * Send a ping message to keep the connection alive
    */
   keepAlive(thinking, mode) {
+    logger.debug(`[API] Sending keep alive message: ${thinking}`);
     this.socket.volatile.emit("session-alive", {
       sid: this.sessionId,
       time: Date.now(),
@@ -905,11 +1244,17 @@ class ApiMachineClient {
           if (!session) {
             throw new Error("Failed to spawn session");
           }
-          logger.debug(`[API MACHINE] Spawned session ${session.happySessionId || "pending"} with PID ${session.pid}`);
+          if (session.error) {
+            throw new Error(session.error);
+          }
+          logger.debug(`[API MACHINE] Spawned session ${session.happySessionId || "WARNING - not session Id recieved in webhook"} with PID ${session.pid}`);
           if (!session.happySessionId) {
             throw new Error(`Session spawned (PID ${session.pid}) but no sessionId received from webhook. The session process may still be initializing.`);
           }
-          const response = { sessionId: session.happySessionId };
+          const response = {
+            sessionId: session.happySessionId,
+            message: session.message
+          };
           logger.debug(`[API MACHINE] Sending RPC response:`, response);
           callback(encodeBase64(encrypt(response, this.secret)));
           return;
@@ -995,9 +1340,7 @@ class ApiMachineClient {
         machineId: this.machine.id,
         time: Date.now()
       };
-      if (process.env.VERBOSE) {
-        logger.debugLargeJson(`[API MACHINE] Emitting machine-alive`, payload);
-      }
+      logger.debugLargeJson(`[API MACHINE] Emitting machine-alive`, payload);
       this.socket.emit("machine-alive", payload);
     }, 2e4);
     logger.debug("[API MACHINE] Keep-alive started (20s interval)");
@@ -1243,6 +1586,11 @@ class ApiClient {
         timeout: 5e3
       }
     );
+    if (response.status !== 200) {
+      console.error(chalk.red(`[API] Failed to create machine: ${response.statusText}`));
+      console.log(chalk.yellow(`[API] Failed to create machine: ${response.statusText}, most likely you have re-authenticated, but you still have a machine associated with the old account. Now we are trying to re-associate the machine with the new account. That is not allowed. Please run 'happy doctor clean' to clean up your happy state, and try your original command again. Please create an issue on github if this is causing you problems. We apologize for the inconvenience.`));
+      process.exit(1);
+    }
     const raw = response.data.machine;
     logger.debug(`[API] Machine ${opts.machineId} registered/updated with server`);
     const machine = {
@@ -1269,52 +1617,52 @@ class ApiClient {
   }
 }
 
-const UsageSchema = z.object({
-  input_tokens: z.number().int().nonnegative(),
-  cache_creation_input_tokens: z.number().int().nonnegative().optional(),
-  cache_read_input_tokens: z.number().int().nonnegative().optional(),
-  output_tokens: z.number().int().nonnegative(),
-  service_tier: z.string().optional()
+const UsageSchema = z$1.object({
+  input_tokens: z$1.number().int().nonnegative(),
+  cache_creation_input_tokens: z$1.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z$1.number().int().nonnegative().optional(),
+  output_tokens: z$1.number().int().nonnegative(),
+  service_tier: z$1.string().optional()
 }).passthrough();
-const RawJSONLinesSchema = z.discriminatedUnion("type", [
+const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
   // User message - validates uuid and message.content
-  z.object({
-    type: z.literal("user"),
-    isSidechain: z.boolean().optional(),
-    isMeta: z.boolean().optional(),
-    uuid: z.string(),
+  z$1.object({
+    type: z$1.literal("user"),
+    isSidechain: z$1.boolean().optional(),
+    isMeta: z$1.boolean().optional(),
+    uuid: z$1.string(),
     // Used in getMessageKey()
-    message: z.object({
-      content: z.union([z.string(), z.any()])
+    message: z$1.object({
+      content: z$1.union([z$1.string(), z$1.any()])
       // Used in sessionScanner.ts
     }).passthrough()
   }).passthrough(),
   // Assistant message - validates message object with usage and content
-  z.object({
-    uuid: z.string(),
-    type: z.literal("assistant"),
-    message: z.object({
+  z$1.object({
+    uuid: z$1.string(),
+    type: z$1.literal("assistant"),
+    message: z$1.object({
       // Entire message used in getMessageKey()
       usage: UsageSchema.optional(),
       // Used in apiSession.ts
-      content: z.any()
+      content: z$1.any()
       // Used in tests
     }).passthrough()
   }).passthrough(),
   // Summary message - validates summary and leafUuid
-  z.object({
-    type: z.literal("summary"),
-    summary: z.string(),
+  z$1.object({
+    type: z$1.literal("summary"),
+    summary: z$1.string(),
     // Used in apiSession.ts
-    leafUuid: z.string()
+    leafUuid: z$1.string()
     // Used in getMessageKey()
   }).passthrough(),
   // System message - validates uuid
-  z.object({
-    type: z.literal("system"),
-    uuid: z.string()
+  z$1.object({
+    type: z$1.literal("system"),
+    uuid: z$1.string()
     // Used in getMessageKey()
   }).passthrough()
 ]);
 
-export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, backoff as b, configuration as c, delay as d, AsyncLock as e, encodeBase64 as f, encodeBase64Url as g, decodeBase64 as h, logger as l };
+export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, backoff as b, configuration as c, delay as d, AsyncLock as e, clearDaemonState as f, readSettings as g, readCredentials as h, encodeBase64 as i, encodeBase64Url as j, decodeBase64 as k, logger as l, acquireDaemonLock as m, writeDaemonState as n, releaseDaemonLock as o, packageJson as p, clearCredentials as q, readDaemonState as r, clearMachineId as s, getLatestDaemonLog as t, updateSettings as u, writeCredentials as w };