happy-coder 0.9.0-6 → 0.9.1

package/dist/{types-a-nJyP-e.cjs → types-DNUk09Np.cjs}

@@ -3,30 +3,177 @@
 var axios = require('axios');
 var chalk = require('chalk');
 var fs = require('fs');
+var node_fs = require('node:fs');
 var os = require('node:os');
 var node_path = require('node:path');
 var promises = require('node:fs/promises');
-var node_fs = require('node:fs');
-var node_events = require('node:events');
-var socket_ioClient = require('socket.io-client');
 var z = require('zod');
 var node_crypto = require('node:crypto');
 var tweetnacl = require('tweetnacl');
+var node_events = require('node:events');
+var socket_ioClient = require('socket.io-client');
 var expoServerSdk = require('expo-server-sdk');
 
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
+
+var name = "happy-coder";
+var version = "0.9.1";
+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$1 = "./dist/index.mjs";
+var types = "./dist/index.d.cts";
+var exports$1 = {
+	".": {
+		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$1,
+	types: types,
+	exports: exports$1,
+	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";
+    this.serverUrl = process.env.HAPPY_SERVER_URL || "https://api.cluster-fluster.com";
     const args = process.argv.slice(2);
     this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && args[1] === "start-sync";
     if (process.env.HAPPY_HOME_DIR) {
@@ -36,15 +183,231 @@ class Configuration {
       this.happyHomeDir = node_path.join(os.homedir(), ".happy");
     }
     this.logsDir = node_path.join(this.happyHomeDir, "logs");
-    this.daemonLogsDir = node_path.join(this.happyHomeDir, "logs-daemon");
     this.settingsFile = node_path.join(this.happyHomeDir, "settings.json");
     this.privateKeyFile = node_path.join(this.happyHomeDir, "access.key");
     this.daemonStateFile = node_path.join(this.happyHomeDir, "daemon.state.json");
+    this.daemonLockFile = node_path.join(this.happyHomeDir, "daemon.state.json.lock");
     this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.HAPPY_EXPERIMENTAL?.toLowerCase() || "");
+    this.currentCliVersion = packageJson.version;
+    if (!node_fs.existsSync(this.happyHomeDir)) {
+      node_fs.mkdirSync(this.happyHomeDir, { recursive: true });
+    }
+    if (!node_fs.existsSync(this.logsDir)) {
+      node_fs.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(node_crypto.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 (!node_fs.existsSync(configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await promises.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 promises.open(lockFile, node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.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 promises.stat(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await promises.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 (!node_fs.existsSync(configuration.happyHomeDir)) {
+      await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+    }
+    await promises.writeFile(tmpFile, JSON.stringify(updated, null, 2));
+    await promises.rename(tmpFile, configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await promises.unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z__namespace.object({
+  secret: z__namespace.string().base64(),
+  token: z__namespace.string()
+});
+async function readCredentials() {
+  if (!node_fs.existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await promises.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 (!node_fs.existsSync(configuration.happyHomeDir)) {
+    await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+  }
+  await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token
+  }, null, 2));
+}
+async function clearCredentials() {
+  if (node_fs.existsSync(configuration.privateKeyFile)) {
+    await promises.unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!node_fs.existsSync(configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await promises.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) {
+  node_fs.writeFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2), "utf-8");
+}
+async function clearDaemonState() {
+  if (node_fs.existsSync(configuration.daemonStateFile)) {
+    await promises.unlink(configuration.daemonStateFile);
+  }
+  if (node_fs.existsSync(configuration.daemonLockFile)) {
+    try {
+      await promises.unlink(configuration.daemonLockFile);
+    } catch {
+    }
+  }
+}
+async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const fileHandle = await promises.open(
+        configuration.daemonLockFile,
+        node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = node_fs.readFileSync(configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              node_fs.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 (node_fs.existsSync(configuration.daemonLockFile)) {
+      node_fs.unlinkSync(configuration.daemonLockFile);
+    }
+  } catch {
+  }
+}
+
 function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
   return date.toLocaleString("sv-SE", {
     timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
@@ -54,7 +417,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", {
@@ -66,17 +429,14 @@ function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
     fractionalSecondDigits: 3
   });
 }
-async function getSessionLogPath() {
-  if (!node_fs.existsSync(configuration.logsDir)) {
-    await promises.mkdir(configuration.logsDir, { recursive: true });
-  }
+function getSessionLogPath() {
   const timestamp = createTimestampForFilename();
   const filename = configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
   return node_path.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"));
@@ -189,25 +549,59 @@ class Logger {
       this.sendToRemoteServer(level, message, ...args).catch(() => {
       });
     }
-    this.logFilePathPromise.then((logFilePath) => {
-      try {
-        fs.appendFileSync(logFilePath, logLine);
-      } catch (appendError) {
-        if (process.env.DEBUG) {
-          console.error("Failed to append to log file:", appendError);
-          throw appendError;
-        }
-      }
-    }).catch((error) => {
+    try {
+      fs.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("[DEV MODE ONLY THROWING] Failed to append to log file:", appendError);
+        throw appendError;
       }
-    });
+    }
   }
 }
 let logger = new Logger();
+async function listDaemonLogFiles(limit = 50) {
+  try {
+    const logsDir = configuration.logsDir;
+    if (!node_fs.existsSync(logsDir)) {
+      return [];
+    }
+    const logs = node_fs.readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
+      const fullPath = node_path.join(logsDir, file);
+      const stats = node_fs.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 && node_fs.existsSync(state.daemonLogPath)) {
+        const stats = node_fs.statSync(state.daemonLogPath);
+        const persisted = {
+          file: node_path.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.z.object({
   c: z.z.string(),
@@ -266,7 +660,23 @@ z.z.object({
   metadata: z.z.any(),
   metadataVersion: z.z.number(),
   agentState: z.z.any().nullable(),
-  agentStateVersion: z.z.number()
+  agentStateVersion: z.z.number(),
+  // Connectivity tracking (from server)
+  connectivityStatus: z.z.union([
+    z.z.enum(["neverConnected", "online", "offline"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional(),
+  connectivityStatusSince: z.z.number().optional(),
+  connectivityStatusReason: z.z.string().optional(),
+  // State tracking (from server)
+  state: z.z.union([
+    z.z.enum(["running", "archiveRequested", "archived"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional(),
+  stateSince: z.z.number().optional(),
+  stateReason: z.z.string().optional()
 });
 z.z.object({
   host: z.z.string(),
@@ -304,7 +714,23 @@ z.z.object({
   active: z.z.boolean(),
   activeAt: z.z.number(),
   createdAt: z.z.number(),
-  updatedAt: z.z.number()
+  updatedAt: z.z.number(),
+  // Connectivity tracking (from server)
+  connectivityStatus: z.z.union([
+    z.z.enum(["neverConnected", "online", "offline"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional(),
+  connectivityStatusSince: z.z.number().optional(),
+  connectivityStatusReason: z.z.string().optional(),
+  // State tracking (from server)
+  state: z.z.union([
+    z.z.enum(["running", "archiveRequested", "archived"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional(),
+  stateSince: z.z.number().optional(),
+  stateReason: z.z.string().optional()
 });
 z.z.object({
   content: SessionMessageContentSchema,
@@ -364,44 +790,6 @@ const AgentMessageSchema = z.z.object({
 });
 z.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(node_crypto.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));
-}
-
 async function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -655,6 +1043,9 @@ class ApiSessionClient extends node_events.EventEmitter {
    * Send a ping message to keep the connection alive
    */
   keepAlive(thinking, mode) {
+    if (process.env.DEBUG) {
+      logger.debug(`[API] Sending keep alive message: ${thinking}`);
+    }
     this.socket.volatile.emit("session-alive", {
       sid: this.sessionId,
       time: Date.now(),
@@ -907,11 +1298,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;
@@ -997,7 +1394,7 @@ class ApiMachineClient {
         machineId: this.machine.id,
         time: Date.now()
       };
-      if (process.env.VERBOSE) {
+      if (process.env.DEBUG) {
         logger.debugLargeJson(`[API MACHINE] Emitting machine-alive`, payload);
       }
       this.socket.emit("machine-alive", payload);
@@ -1025,7 +1422,7 @@ class PushNotificationClient {
   token;
   baseUrl;
   expo;
-  constructor(token, baseUrl = "https://handy-api.korshakov.org") {
+  constructor(token, baseUrl = "https://api.cluster-fluster.com") {
     this.token = token;
     this.baseUrl = baseUrl;
     this.expo = new expoServerSdk.Expo();
@@ -1245,6 +1642,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 = {
@@ -1323,10 +1725,23 @@ exports.ApiClient = ApiClient;
 exports.ApiSessionClient = ApiSessionClient;
 exports.AsyncLock = AsyncLock;
 exports.RawJSONLinesSchema = RawJSONLinesSchema;
+exports.acquireDaemonLock = acquireDaemonLock;
 exports.backoff = backoff;
+exports.clearCredentials = clearCredentials;
+exports.clearDaemonState = clearDaemonState;
+exports.clearMachineId = clearMachineId;
 exports.configuration = configuration;
 exports.decodeBase64 = decodeBase64;
 exports.delay = delay;
 exports.encodeBase64 = encodeBase64;
 exports.encodeBase64Url = encodeBase64Url;
+exports.getLatestDaemonLog = getLatestDaemonLog;
 exports.logger = logger;
+exports.packageJson = packageJson;
+exports.readCredentials = readCredentials;
+exports.readDaemonState = readDaemonState;
+exports.readSettings = readSettings;
+exports.releaseDaemonLock = releaseDaemonLock;
+exports.updateSettings = updateSettings;
+exports.writeCredentials = writeCredentials;
+exports.writeDaemonState = writeDaemonState;