happy-coder 0.1.6 → 0.1.9

package/dist/types-mykDX2xe.cjs

@@ -0,0 +1,872 @@
+'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;
+  // Directories and paths (from persistence)
+  happyDir;
+  logsDir;
+  settingsFile;
+  privateKeyFile;
+  constructor(location) {
+    this.serverUrl = process.env.HANDY_SERVER_URL || "https://handy-api.korshakov.org";
+    if (location === "local") {
+      this.happyDir = node_path.join(process.cwd(), ".happy");
+    } else {
+      this.happyDir = node_path.join(os.homedir(), ".happy");
+    }
+    this.logsDir = node_path.join(this.happyDir, "logs");
+    this.settingsFile = node_path.join(this.happyDir, "settings.json");
+    this.privateKeyFile = node_path.join(this.happyDir, "access.key");
+  }
+}
+exports.configuration = void 0;
+function initializeConfiguration(location) {
+  exports.configuration = new Configuration(location);
+}
+
+async function getSessionLogPath() {
+  if (!node_fs.existsSync(exports.configuration.logsDir)) {
+    await promises.mkdir(exports.configuration.logsDir, { recursive: true });
+  }
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.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, "");
+  return node_path.join(exports.configuration.logsDir, `${timestamp}.log`);
+}
+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 (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      fractionalSecondDigits: 3
+    });
+  }
+  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(),
+    metadata: z.z.string()
+  }).nullish(),
+  agentState: z.z.object({
+    version: z.z.number(),
+    agentState: 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()
+});
+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$1 = 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
+  sentFrom: z.z.enum(["mobile", "cli"]).optional()
+  // Source identifier
+});
+const AgentMessageSchema = z.z.object({
+  role: z.z.literal("agent"),
+  content: z.z.object({
+    type: z.z.literal("output"),
+    data: z.z.any()
+  })
+});
+z.z.union([UserMessageSchema$1, 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.max(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) => {
+      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$1.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.metadata), this.secret);
+          this.metadataVersion = data.body.metadata.version;
+        }
+        if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
+          this.agentState = data.body.agentState.agentState ? decrypt(decodeBase64(data.body.agentState.agentState), this.secret) : null;
+          this.agentStateVersion = data.body.agentState.version;
+        }
+      }
+    });
+    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") {
+      content = {
+        role: "user",
+        content: {
+          type: "text",
+          text: body.message.content
+        }
+      };
+    } else {
+      content = {
+        role: "agent",
+        content: {
+          type: "output",
+          data: body
+          // This wraps the entire Claude message
+        }
+      };
+    }
+    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);
+      }
+    }
+  }
+  /**
+   * Send a ping message to keep the connection alive
+   */
+  keepAlive(thinking) {
+    this.socket.volatile.emit("session-alive", {
+      sid: this.sessionId,
+      time: Date.now(),
+      thinking
+    });
+  }
+  /**
+   * 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) {
+    console.log("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;
+        console.log("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") {
+        console.error("Agent state update error", answer);
+      }
+    });
+  }
+  /**
+   * 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.info(`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.info(`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.info("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.info(`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.info("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()
+});
+const TextContentSchema = z.z.object({
+  type: z.z.literal("text"),
+  text: z.z.string()
+});
+const ThinkingContentSchema = z.z.object({
+  type: z.z.literal("thinking"),
+  thinking: z.z.string(),
+  signature: z.z.string()
+});
+const ToolUseContentSchema = z.z.object({
+  type: z.z.literal("tool_use"),
+  id: z.z.string(),
+  name: z.z.string(),
+  input: z.z.unknown()
+  // Tool-specific input parameters
+});
+const ToolResultContentSchema = z.z.object({
+  tool_use_id: z.z.string(),
+  type: z.z.literal("tool_result"),
+  content: z.z.union([
+    z.z.string(),
+    // For simple string responses
+    z.z.array(TextContentSchema)
+    // For structured content blocks (typically text)
+  ]),
+  is_error: z.z.boolean().optional()
+});
+const ContentSchema = z.z.union([
+  TextContentSchema,
+  ThinkingContentSchema,
+  ToolUseContentSchema,
+  ToolResultContentSchema
+]);
+const UserMessageSchema = z.z.object({
+  role: z.z.literal("user"),
+  content: z.z.union([
+    z.z.string(),
+    // Simple string content
+    z.z.array(z.z.union([ToolResultContentSchema, TextContentSchema]))
+  ])
+});
+const AssistantMessageSchema = z.z.object({
+  id: z.z.string(),
+  type: z.z.literal("message"),
+  role: z.z.literal("assistant"),
+  model: z.z.string(),
+  content: z.z.array(ContentSchema),
+  stop_reason: z.z.string().nullable(),
+  stop_sequence: z.z.string().nullable(),
+  usage: UsageSchema
+});
+const BaseEntrySchema = z.z.object({
+  cwd: z.z.string(),
+  sessionId: z.z.string(),
+  version: z.z.string(),
+  uuid: z.z.string(),
+  timestamp: z.z.string().datetime(),
+  parent_tool_use_id: z.z.string().nullable().optional()
+});
+const SummaryEntrySchema = z.z.object({
+  type: z.z.literal("summary"),
+  summary: z.z.string(),
+  leafUuid: z.z.string()
+});
+const UserEntrySchema = BaseEntrySchema.extend({
+  type: z.z.literal("user"),
+  message: UserMessageSchema,
+  isMeta: z.z.boolean().optional(),
+  toolUseResult: z.z.unknown().optional()
+  // Present when user responds to tool use
+});
+const AssistantEntrySchema = BaseEntrySchema.extend({
+  type: z.z.literal("assistant"),
+  message: AssistantMessageSchema,
+  requestId: z.z.string().optional()
+});
+const SystemEntrySchema = BaseEntrySchema.extend({
+  type: z.z.literal("system"),
+  content: z.z.string(),
+  isMeta: z.z.boolean().optional(),
+  level: z.z.string().optional(),
+  parentUuid: z.z.string().optional(),
+  isSidechain: z.z.boolean().optional(),
+  userType: z.z.string().optional()
+});
+const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
+  UserEntrySchema,
+  AssistantEntrySchema,
+  SummaryEntrySchema,
+  SystemEntrySchema
+]);
+
+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;