happy-coder 0.3.1-beta.1 → 0.4.0

package/dist/types-BeUppqJU.cjs

@@ -1,886 +0,0 @@
-'use strict';
-
-var axios = require('axios');
-var chalk = require('chalk');
-var fs = require('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 expoServerSdk = require('expo-server-sdk');
-
-class Configuration {
-  serverUrl;
-  installationLocation;
-  isDaemonProcess;
-  // Directories and paths (from persistence)
-  happyDir;
-  logsDir;
-  daemonLogsDir;
-  settingsFile;
-  privateKeyFile;
-  daemonMetadataFile;
-  constructor(location) {
-    this.serverUrl = process.env.HANDY_SERVER_URL || "https://handy-api.korshakov.org";
-    const args = process.argv.slice(2);
-    this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && (args[1] === "start" || args[1] === "stop");
-    if (location === "local") {
-      this.happyDir = node_path.join(process.cwd(), ".happy");
-      this.installationLocation = "local";
-    } else if (location === "global") {
-      this.happyDir = node_path.join(os.homedir(), ".happy");
-      this.installationLocation = "global";
-    } else {
-      this.happyDir = node_path.join(location, ".happy");
-      this.installationLocation = "global";
-    }
-    this.logsDir = node_path.join(this.happyDir, "logs");
-    this.daemonLogsDir = node_path.join(this.happyDir, "logs-daemon");
-    this.settingsFile = node_path.join(this.happyDir, "settings.json");
-    this.privateKeyFile = node_path.join(this.happyDir, "access.key");
-    this.daemonMetadataFile = node_path.join(this.happyDir, "daemon-metadata.json");
-  }
-}
-exports.configuration = void 0;
-function initializeConfiguration(location) {
-  exports.configuration = new Configuration(location);
-}
-
-function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
-  return date.toLocaleString("sv-SE", {
-    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit"
-  }).replace(/[: ]/g, "-").replace(/,/g, "");
-}
-function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
-  return date.toLocaleTimeString("en-US", {
-    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    hour12: false,
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    fractionalSecondDigits: 3
-  });
-}
-async function getSessionLogPath() {
-  if (!node_fs.existsSync(exports.configuration.logsDir)) {
-    await promises.mkdir(exports.configuration.logsDir, { recursive: true });
-  }
-  const timestamp = createTimestampForFilename();
-  const filename = exports.configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
-  return node_path.join(exports.configuration.logsDir, filename);
-}
-class Logger {
-  constructor(logFilePathPromise = getSessionLogPath()) {
-    this.logFilePathPromise = logFilePathPromise;
-  }
-  // Use local timezone for simplicity of locating the logs,
-  // in practice you will not need absolute timestamps
-  localTimezoneTimestamp() {
-    return createTimestampForLogEntry();
-  }
-  debug(message, ...args) {
-    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, ...args);
-  }
-  debugLargeJson(message, object, maxStringLength = 100, maxArrayLength = 10) {
-    if (!process.env.DEBUG) {
-      this.debug(`In production, skipping message inspection`);
-    }
-    const truncateStrings = (obj) => {
-      if (typeof obj === "string") {
-        return obj.length > maxStringLength ? obj.substring(0, maxStringLength) + "... [truncated for logs]" : obj;
-      }
-      if (Array.isArray(obj)) {
-        const truncatedArray = obj.map((item) => truncateStrings(item)).slice(0, maxArrayLength);
-        if (obj.length > maxArrayLength) {
-          truncatedArray.push(`... [truncated array for logs up to ${maxArrayLength} items]`);
-        }
-        return truncatedArray;
-      }
-      if (obj && typeof obj === "object") {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-          if (key === "usage") {
-            continue;
-          }
-          result[key] = truncateStrings(value);
-        }
-        return result;
-      }
-      return obj;
-    };
-    const truncatedObject = truncateStrings(object);
-    const json = JSON.stringify(truncatedObject, null, 2);
-    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, "\n", json);
-  }
-  info(message, ...args) {
-    this.logToConsole("info", "", message, ...args);
-    this.debug(message, args);
-  }
-  infoDeveloper(message, ...args) {
-    this.debug(message, ...args);
-    if (process.env.DEBUG) {
-      this.logToConsole("info", "[DEV]", message, ...args);
-    }
-  }
-  logToConsole(level, prefix, message, ...args) {
-    switch (level) {
-      case "debug": {
-        console.log(chalk.gray(prefix), message, ...args);
-        break;
-      }
-      case "error": {
-        console.error(chalk.red(prefix), message, ...args);
-        break;
-      }
-      case "info": {
-        console.log(chalk.blue(prefix), message, ...args);
-        break;
-      }
-      case "warn": {
-        console.log(chalk.yellow(prefix), message, ...args);
-        break;
-      }
-      default: {
-        this.debug("Unknown log level:", level);
-        console.log(chalk.blue(prefix), message, ...args);
-        break;
-      }
-    }
-  }
-  logToFile(prefix, message, ...args) {
-    const logLine = `${prefix} ${message} ${args.map(
-      (arg) => typeof arg === "string" ? arg : JSON.stringify(arg)
-    ).join(" ")}
-`;
-    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) => {
-      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);
-      }
-    });
-  }
-}
-exports.logger = void 0;
-function initLoggerWithGlobalConfiguration() {
-  exports.logger = new Logger();
-  if (process.env.DEBUG) {
-    exports.logger.logFilePathPromise.then((logPath) => {
-      exports.logger.info(chalk.yellow("[DEBUG MODE] Debug logging enabled"));
-      exports.logger.info(chalk.gray(`Log file: ${logPath}`));
-    });
-  }
-}
-
-const SessionMessageContentSchema = z.z.object({
-  c: z.z.string(),
-  // Base64 encoded encrypted content
-  t: z.z.literal("encrypted")
-});
-const UpdateBodySchema = z.z.object({
-  message: z.z.object({
-    id: z.z.string(),
-    seq: z.z.number(),
-    content: SessionMessageContentSchema
-  }),
-  sid: z.z.string(),
-  // Session ID
-  t: z.z.literal("new-message")
-});
-const UpdateSessionBodySchema = z.z.object({
-  t: z.z.literal("update-session"),
-  sid: z.z.string(),
-  metadata: z.z.object({
-    version: z.z.number(),
-    value: z.z.string()
-  }).nullish(),
-  agentState: z.z.object({
-    version: z.z.number(),
-    value: z.z.string()
-  }).nullish()
-});
-z.z.object({
-  id: z.z.string(),
-  seq: z.z.number(),
-  body: z.z.union([UpdateBodySchema, UpdateSessionBodySchema]),
-  createdAt: z.z.number()
-});
-z.z.object({
-  createdAt: z.z.number(),
-  id: z.z.string(),
-  seq: z.z.number(),
-  updatedAt: z.z.number(),
-  metadata: z.z.any(),
-  metadataVersion: z.z.number(),
-  agentState: z.z.any().nullable(),
-  agentStateVersion: z.z.number()
-});
-z.z.object({
-  content: SessionMessageContentSchema,
-  createdAt: z.z.number(),
-  id: z.z.string(),
-  seq: z.z.number(),
-  updatedAt: z.z.number()
-});
-const MessageMetaSchema = z.z.object({
-  sentFrom: z.z.string().optional(),
-  // Source identifier
-  permissionMode: z.z.string().optional()
-  // Permission mode for this message
-});
-z.z.object({
-  session: z.z.object({
-    id: z.z.string(),
-    tag: z.z.string(),
-    seq: z.z.number(),
-    createdAt: z.z.number(),
-    updatedAt: z.z.number(),
-    metadata: z.z.string(),
-    metadataVersion: z.z.number(),
-    agentState: z.z.string().nullable(),
-    agentStateVersion: z.z.number()
-  })
-});
-const UserMessageSchema = z.z.object({
-  role: z.z.literal("user"),
-  content: z.z.object({
-    type: z.z.literal("text"),
-    text: z.z.string()
-  }),
-  localKey: z.z.string().optional(),
-  // Mobile messages include this
-  meta: MessageMetaSchema.optional()
-});
-const AgentMessageSchema = z.z.object({
-  role: z.z.literal("agent"),
-  content: z.z.object({
-    type: z.z.literal("output"),
-    data: z.z.any()
-  }),
-  meta: MessageMetaSchema.optional()
-});
-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) {
-    return null;
-  }
-  return JSON.parse(new TextDecoder().decode(decrypted));
-}
-
-async function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
-  let maxDelayRet = minDelay + (maxDelay - minDelay) / maxFailureCount * Math.min(currentFailureCount, maxFailureCount);
-  return Math.round(Math.random() * maxDelayRet);
-}
-function createBackoff(opts) {
-  return async (callback) => {
-    let currentFailureCount = 0;
-    const minDelay = 250;
-    const maxDelay = 1e3;
-    const maxFailureCount = 50;
-    while (true) {
-      try {
-        return await callback();
-      } catch (e) {
-        if (currentFailureCount < maxFailureCount) {
-          currentFailureCount++;
-        }
-        let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
-        await delay(waitForRequest);
-      }
-    }
-  };
-}
-let backoff = createBackoff();
-
-class ApiSessionClient extends node_events.EventEmitter {
-  token;
-  secret;
-  sessionId;
-  metadata;
-  metadataVersion;
-  agentState;
-  agentStateVersion;
-  socket;
-  pendingMessages = [];
-  pendingMessageCallback = null;
-  rpcHandlers = /* @__PURE__ */ new Map();
-  constructor(token, secret, session) {
-    super();
-    this.token = token;
-    this.secret = secret;
-    this.sessionId = session.id;
-    this.metadata = session.metadata;
-    this.metadataVersion = session.metadataVersion;
-    this.agentState = session.agentState;
-    this.agentStateVersion = session.agentStateVersion;
-    this.socket = socket_ioClient.io(exports.configuration.serverUrl, {
-      auth: {
-        token: this.token,
-        clientType: "session-scoped",
-        sessionId: this.sessionId
-      },
-      path: "/v1/updates",
-      reconnection: true,
-      reconnectionAttempts: Infinity,
-      reconnectionDelay: 1e3,
-      reconnectionDelayMax: 5e3,
-      transports: ["websocket"],
-      withCredentials: true,
-      autoConnect: false
-    });
-    this.socket.on("connect", () => {
-      exports.logger.debug("Socket connected successfully");
-      this.reregisterHandlers();
-    });
-    this.socket.on("rpc-request", async (data, callback) => {
-      try {
-        const method = data.method;
-        const handler = this.rpcHandlers.get(method);
-        if (!handler) {
-          exports.logger.debug("[SOCKET] [RPC] [ERROR] method not found", { method });
-          const errorResponse = { error: "Method not found" };
-          const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
-          callback(encryptedError);
-          return;
-        }
-        const decryptedParams = decrypt(decodeBase64(data.params), this.secret);
-        const result = await handler(decryptedParams);
-        const encryptedResponse = encodeBase64(encrypt(result, this.secret));
-        callback(encryptedResponse);
-      } catch (error) {
-        exports.logger.debug("[SOCKET] [RPC] [ERROR] Error handling RPC request", { error });
-        const errorResponse = { error: error instanceof Error ? error.message : "Unknown error" };
-        const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
-        callback(encryptedError);
-      }
-    });
-    this.socket.on("disconnect", (reason) => {
-      exports.logger.debug("[API] Socket disconnected:", reason);
-    });
-    this.socket.on("connect_error", (error) => {
-      exports.logger.debug("[API] Socket connection error:", error);
-    });
-    this.socket.on("update", (data) => {
-      try {
-        exports.logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
-        if (!data.body) {
-          exports.logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
-          return;
-        }
-        if (data.body.t === "new-message" && data.body.message.content.t === "encrypted") {
-          const body = decrypt(decodeBase64(data.body.message.content.c), this.secret);
-          exports.logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
-          const userResult = UserMessageSchema.safeParse(body);
-          if (userResult.success) {
-            if (this.pendingMessageCallback) {
-              this.pendingMessageCallback(userResult.data);
-            } else {
-              this.pendingMessages.push(userResult.data);
-            }
-          } else {
-            this.emit("message", body);
-          }
-        } else if (data.body.t === "update-session") {
-          if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
-            this.metadata = decrypt(decodeBase64(data.body.metadata.value), this.secret);
-            this.metadataVersion = data.body.metadata.version;
-          }
-          if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
-            this.agentState = data.body.agentState.value ? decrypt(decodeBase64(data.body.agentState.value), this.secret) : null;
-            this.agentStateVersion = data.body.agentState.version;
-          }
-        } else {
-          this.emit("message", data.body);
-        }
-      } catch (error) {
-        exports.logger.debug("[SOCKET] [UPDATE] [ERROR] Error handling update", { error });
-      }
-    });
-    this.socket.on("error", (error) => {
-      exports.logger.debug("[API] Socket error:", error);
-    });
-    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 (can be MessageContent or raw content for agent messages)
-   */
-  sendClaudeSessionMessage(body) {
-    let content;
-    if (body.type === "user" && typeof body.message.content === "string" && body.isSidechain !== true && body.isMeta !== true) {
-      content = {
-        role: "user",
-        content: {
-          type: "text",
-          text: body.message.content
-        },
-        meta: {
-          sentFrom: "cli"
-        }
-      };
-    } else {
-      content = {
-        role: "agent",
-        content: {
-          type: "output",
-          data: body
-          // This wraps the entire Claude message
-        },
-        meta: {
-          sentFrom: "cli"
-        }
-      };
-    }
-    exports.logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
-    const encrypted = encodeBase64(encrypt(content, this.secret));
-    this.socket.emit("message", {
-      sid: this.sessionId,
-      message: encrypted
-    });
-    if (body.type === "assistant" && body.message.usage) {
-      try {
-        this.sendUsageData(body.message.usage);
-      } catch (error) {
-        exports.logger.debug("[SOCKET] Failed to send usage data:", error);
-      }
-    }
-    if (body.type === "summary" && "summary" in body && "leafUuid" in body) {
-      this.updateMetadata((metadata) => ({
-        ...metadata,
-        summary: {
-          text: body.summary,
-          updatedAt: Date.now()
-        }
-      }));
-    }
-  }
-  sendSessionEvent(event, id) {
-    let content = {
-      role: "agent",
-      content: {
-        id: id ?? node_crypto.randomUUID(),
-        type: "event",
-        data: event
-      }
-    };
-    const encrypted = encodeBase64(encrypt(content, this.secret));
-    this.socket.emit("message", {
-      sid: this.sessionId,
-      message: encrypted
-    });
-  }
-  /**
-   * Send a ping message to keep the connection alive
-   */
-  keepAlive(thinking, mode) {
-    this.socket.volatile.emit("session-alive", {
-      sid: this.sessionId,
-      time: Date.now(),
-      thinking,
-      mode
-    });
-  }
-  /**
-   * Send session death message
-   */
-  sendSessionDeath() {
-    this.socket.emit("session-end", { sid: this.sessionId, time: Date.now() });
-  }
-  /**
-   * Send usage data to the server
-   */
-  sendUsageData(usage) {
-    const totalTokens = usage.input_tokens + usage.output_tokens + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
-    const usageReport = {
-      key: "claude-session",
-      sessionId: this.sessionId,
-      tokens: {
-        total: totalTokens,
-        input: usage.input_tokens,
-        output: usage.output_tokens,
-        cache_creation: usage.cache_creation_input_tokens || 0,
-        cache_read: usage.cache_read_input_tokens || 0
-      },
-      cost: {
-        // TODO: Calculate actual costs based on pricing
-        // For now, using placeholder values
-        total: 0,
-        input: 0,
-        output: 0
-      }
-    };
-    exports.logger.debugLargeJson("[SOCKET] Sending usage data:", usageReport);
-    this.socket.emit("usage-report", usageReport);
-  }
-  /**
-   * Update session metadata
-   * @param handler - Handler function that returns the updated metadata
-   */
-  updateMetadata(handler) {
-    backoff(async () => {
-      let updated = handler(this.metadata);
-      const answer = await this.socket.emitWithAck("update-metadata", { sid: this.sessionId, expectedVersion: this.metadataVersion, metadata: encodeBase64(encrypt(updated, this.secret)) });
-      if (answer.result === "success") {
-        this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
-        this.metadataVersion = answer.version;
-      } else if (answer.result === "version-mismatch") {
-        if (answer.version > this.metadataVersion) {
-          this.metadataVersion = answer.version;
-          this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
-        }
-        throw new Error("Metadata version mismatch");
-      } else if (answer.result === "error") ;
-    });
-  }
-  /**
-   * Update session agent state
-   * @param handler - Handler function that returns the updated agent state
-   */
-  updateAgentState(handler) {
-    exports.logger.debugLargeJson("Updating agent state", this.agentState);
-    backoff(async () => {
-      let updated = handler(this.agentState || {});
-      const answer = await this.socket.emitWithAck("update-state", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? encodeBase64(encrypt(updated, this.secret)) : null });
-      if (answer.result === "success") {
-        this.agentState = answer.agentState ? decrypt(decodeBase64(answer.agentState), this.secret) : null;
-        this.agentStateVersion = answer.version;
-        exports.logger.debug("Agent state updated", this.agentState);
-      } else if (answer.result === "version-mismatch") {
-        if (answer.version > this.agentStateVersion) {
-          this.agentStateVersion = answer.version;
-          this.agentState = answer.agentState ? decrypt(decodeBase64(answer.agentState), this.secret) : null;
-        }
-        throw new Error("Agent state version mismatch");
-      } else if (answer.result === "error") ;
-    });
-  }
-  /**
-   * Set a custom RPC handler for a specific method with encrypted arguments and responses
-   * @param method - The method name to handle
-   * @param handler - The handler function to call when the method is invoked
-   */
-  setHandler(method, handler) {
-    const prefixedMethod = `${this.sessionId}:${method}`;
-    this.rpcHandlers.set(prefixedMethod, handler);
-    this.socket.emit("rpc-register", { method: prefixedMethod });
-    exports.logger.debug("Registered RPC handler", { method, prefixedMethod });
-  }
-  /**
-   * Re-register all RPC handlers after reconnection
-   */
-  reregisterHandlers() {
-    exports.logger.debug("Re-registering RPC handlers after reconnection", {
-      totalMethods: this.rpcHandlers.size
-    });
-    for (const [prefixedMethod] of this.rpcHandlers) {
-      this.socket.emit("rpc-register", { method: prefixedMethod });
-      exports.logger.debug("Re-registered method", { prefixedMethod });
-    }
-  }
-  /**
-   * Wait for socket buffer to flush
-   */
-  async flush() {
-    if (!this.socket.connected) {
-      return;
-    }
-    return new Promise((resolve) => {
-      this.socket.emit("ping", () => {
-        resolve();
-      });
-      setTimeout(() => {
-        resolve();
-      }, 1e4);
-    });
-  }
-  async close() {
-    this.socket.close();
-  }
-}
-
-class PushNotificationClient {
-  token;
-  baseUrl;
-  expo;
-  constructor(token, baseUrl = "https://handy-api.korshakov.org") {
-    this.token = token;
-    this.baseUrl = baseUrl;
-    this.expo = new expoServerSdk.Expo();
-  }
-  /**
-   * Fetch all push tokens for the authenticated user
-   */
-  async fetchPushTokens() {
-    try {
-      const response = await axios.get(
-        `${this.baseUrl}/v1/push-tokens`,
-        {
-          headers: {
-            "Authorization": `Bearer ${this.token}`,
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      exports.logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
-      return response.data.tokens;
-    } catch (error) {
-      exports.logger.debug("[PUSH] [ERROR] Failed to fetch push tokens:", error);
-      throw new Error(`Failed to fetch push tokens: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-   * Send push notification via Expo Push API with retry
-   * @param messages - Array of push messages to send
-   */
-  async sendPushNotifications(messages) {
-    exports.logger.debug(`Sending ${messages.length} push notifications`);
-    const validMessages = messages.filter((message) => {
-      if (Array.isArray(message.to)) {
-        return message.to.every((token) => expoServerSdk.Expo.isExpoPushToken(token));
-      }
-      return expoServerSdk.Expo.isExpoPushToken(message.to);
-    });
-    if (validMessages.length === 0) {
-      exports.logger.debug("No valid Expo push tokens found");
-      return;
-    }
-    const chunks = this.expo.chunkPushNotifications(validMessages);
-    for (const chunk of chunks) {
-      const startTime = Date.now();
-      const timeout = 3e5;
-      let attempt = 0;
-      while (true) {
-        try {
-          const ticketChunk = await this.expo.sendPushNotificationsAsync(chunk);
-          const errors = ticketChunk.filter((ticket) => ticket.status === "error");
-          if (errors.length > 0) {
-            exports.logger.debug("[PUSH] Some notifications failed:", errors);
-          }
-          if (errors.length === ticketChunk.length) {
-            throw new Error("All push notifications in chunk failed");
-          }
-          break;
-        } catch (error) {
-          const elapsed = Date.now() - startTime;
-          if (elapsed >= timeout) {
-            exports.logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
-            break;
-          }
-          attempt++;
-          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
-          const remainingTime = timeout - elapsed;
-          const waitTime = Math.min(delay, remainingTime);
-          if (waitTime > 0) {
-            exports.logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
-            await new Promise((resolve) => setTimeout(resolve, waitTime));
-          }
-        }
-      }
-    }
-    exports.logger.debug(`Push notifications sent successfully`);
-  }
-  /**
-   * Send a push notification to all registered devices for the user
-   * @param title - Notification title
-   * @param body - Notification body
-   * @param data - Additional data to send with the notification
-   */
-  async sendToAllDevices(title, body, data) {
-    const tokens = await this.fetchPushTokens();
-    if (tokens.length === 0) {
-      exports.logger.debug("No push tokens found for user");
-      return;
-    }
-    const messages = tokens.map((token) => ({
-      to: token.token,
-      title,
-      body,
-      data,
-      sound: "default",
-      priority: "high"
-    }));
-    await this.sendPushNotifications(messages);
-  }
-}
-
-class ApiClient {
-  token;
-  secret;
-  pushClient;
-  constructor(token, secret) {
-    this.token = token;
-    this.secret = secret;
-    this.pushClient = new PushNotificationClient(token);
-  }
-  /**
-   * Create a new session or load existing one with the given tag
-   */
-  async getOrCreateSession(opts) {
-    try {
-      const response = await axios.post(
-        `${exports.configuration.serverUrl}/v1/sessions`,
-        {
-          tag: opts.tag,
-          metadata: encodeBase64(encrypt(opts.metadata, this.secret)),
-          agentState: opts.state ? encodeBase64(encrypt(opts.state, this.secret)) : null
-        },
-        {
-          headers: {
-            "Authorization": `Bearer ${this.token}`,
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      exports.logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
-      let raw = response.data.session;
-      let session = {
-        id: raw.id,
-        createdAt: raw.createdAt,
-        updatedAt: raw.updatedAt,
-        seq: raw.seq,
-        metadata: decrypt(decodeBase64(raw.metadata), this.secret),
-        metadataVersion: raw.metadataVersion,
-        agentState: raw.agentState ? decrypt(decodeBase64(raw.agentState), this.secret) : null,
-        agentStateVersion: raw.agentStateVersion
-      };
-      return session;
-    } catch (error) {
-      exports.logger.debug("[API] [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(session) {
-    return new ApiSessionClient(this.token, this.secret, session);
-  }
-  /**
-   * Get push notification client
-   * @returns Push notification client
-   */
-  push() {
-    return this.pushClient;
-  }
-}
-
-const UsageSchema = z.z.object({
-  input_tokens: z.z.number().int().nonnegative(),
-  cache_creation_input_tokens: z.z.number().int().nonnegative().optional(),
-  cache_read_input_tokens: z.z.number().int().nonnegative().optional(),
-  output_tokens: z.z.number().int().nonnegative(),
-  service_tier: z.z.string().optional()
-}).passthrough();
-const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
-  // User message - validates uuid and message.content
-  z.z.object({
-    type: z.z.literal("user"),
-    isSidechain: z.z.boolean().optional(),
-    isMeta: z.z.boolean().optional(),
-    uuid: z.z.string(),
-    // Used in getMessageKey()
-    message: z.z.object({
-      content: z.z.union([z.z.string(), z.z.any()])
-      // Used in sessionScanner.ts
-    }).passthrough()
-  }).passthrough(),
-  // Assistant message - validates message object with usage and content
-  z.z.object({
-    uuid: z.z.string(),
-    type: z.z.literal("assistant"),
-    message: z.z.object({
-      // Entire message used in getMessageKey()
-      usage: UsageSchema.optional(),
-      // Used in apiSession.ts
-      content: z.z.any()
-      // Used in tests
-    }).passthrough()
-  }).passthrough(),
-  // Summary message - validates summary and leafUuid
-  z.z.object({
-    type: z.z.literal("summary"),
-    summary: z.z.string(),
-    // Used in apiSession.ts
-    leafUuid: z.z.string()
-    // Used in getMessageKey()
-  }).passthrough(),
-  // System message - validates uuid
-  z.z.object({
-    type: z.z.literal("system"),
-    uuid: z.z.string()
-    // Used in getMessageKey()
-  }).passthrough()
-]);
-
-exports.ApiClient = ApiClient;
-exports.ApiSessionClient = ApiSessionClient;
-exports.RawJSONLinesSchema = RawJSONLinesSchema;
-exports.backoff = backoff;
-exports.decodeBase64 = decodeBase64;
-exports.delay = delay;
-exports.encodeBase64 = encodeBase64;
-exports.encodeBase64Url = encodeBase64Url;
-exports.initLoggerWithGlobalConfiguration = initLoggerWithGlobalConfiguration;
-exports.initializeConfiguration = initializeConfiguration;