@limrun/api 0.2.0 → 0.5.1

package/src/resources/android-instances-helpers.ts

@@ -0,0 +1,159 @@
+import { exec } from 'child_process';
+import * as net from 'net';
+import { WebSocket } from 'ws';
+
+import { AndroidInstance } from './android-instances';
+
+/**
+ * Opens a WebSocket TCP proxy for the ADB port and connects the local adb
+ * client to it.
+ */
+export const startAdbTunnel = async (
+  androidInstance: AndroidInstance,
+  hostname?: string,
+  port?: number,
+): Promise<Proxy> => {
+  if (!androidInstance.status.adbWebSocketUrl) {
+    throw new Error('ADB WebSocket URL is not available');
+  }
+  const { address, close } = await startTcpProxy(
+    androidInstance.status.adbWebSocketUrl,
+    androidInstance.status.token,
+    hostname ?? '127.0.0.1',
+    port ?? 0,
+  );
+  try {
+    await new Promise<void>((resolve, reject) => {
+      exec(`adb connect ${address.address}:${address.port}`, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  } catch (err) {
+    close();
+    throw err;
+  }
+  return { address, close };
+};
+
+/** Returned by `startTcpProxy` – holds the chosen localhost port and a close callback. */
+export interface Proxy {
+  address: net.AddressInfo;
+  close: () => void;
+}
+
+/**
+ * Starts a one-shot TCP → WebSocket proxy.
+ *
+ * The function creates a local TCP server that listens on an ephemeral port on
+ * 127.0.0.1.  As soon as the **first** TCP client connects the server stops
+ * accepting further connections and forwards all traffic between that client
+ * and `remoteURL` through an authenticated WebSocket.  If you need to proxy
+ * more than one TCP connection, call `startTcpProxy` again to create a new
+ * proxy instance.
+ *
+ * @param remoteURL Remote WebSocket endpoint (e.g. wss://example.com/instance)
+ * @param token     Bearer token sent as `Authorization` header
+ * @param hostname  Optional IP address to listen on. Default is 127.0.0.1
+ * @param port      Optional port number to listen on. Default is to ask Node.js
+ *                  to find an available non-privileged port.
+ */
+export async function startTcpProxy(
+  remoteURL: string,
+  token: string,
+  hostname: string,
+  port: number,
+): Promise<Proxy> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+
+    let ws: WebSocket | undefined;
+    let pingInterval: NodeJS.Timeout | undefined;
+
+    // close helper
+    const close = () => {
+      if (pingInterval) {
+        clearInterval(pingInterval);
+        pingInterval = undefined;
+      }
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.close(1000, 'close');
+      }
+      if (server.listening) {
+        server.close();
+      }
+    };
+
+    // No AbortController support – proxy can be closed via the returned handle
+
+    // TCP server error
+    server.once('error', (err) => {
+      close();
+      reject(new Error(`TCP server error: ${err.message}`));
+    });
+
+    // Listening
+    server.once('listening', () => {
+      const address = server.address();
+      if (!address || typeof address === 'string') {
+        close();
+        return reject(new Error('Failed to obtain listening address'));
+      }
+      resolve({ address, close });
+    });
+
+    // On first TCP connection
+    server.on('connection', (tcpSocket) => {
+      // Single-connection proxy
+      server.close();
+
+      ws = new WebSocket(remoteURL, {
+        headers: { Authorization: `Bearer ${token}` },
+        perMessageDeflate: false,
+      });
+
+      // WebSocket error
+      ws.once('error', (err) => {
+        console.error('WebSocket error:', err);
+        tcpSocket.destroy();
+        close();
+      });
+
+      ws.once('open', () => {
+        const socket = ws as WebSocket; // non-undefined after open
+
+        pingInterval = setInterval(() => {
+          if (socket.readyState === WebSocket.OPEN) {
+            (socket as any).ping();
+          }
+        }, 30_000);
+
+        // TCP → WS
+        tcpSocket.on('data', (chunk) => {
+          if (socket.readyState === WebSocket.OPEN) {
+            socket.send(chunk);
+          }
+        });
+
+        // WS → TCP
+        socket.on('message', (data) => {
+          if (!tcpSocket.destroyed) {
+            tcpSocket.write(data as Buffer);
+          }
+        });
+      });
+
+      // Mutual close
+      tcpSocket.on('close', close);
+      tcpSocket.on('error', (err) => {
+        console.error('TCP socket error:', err);
+        close();
+      });
+
+      ws.on('close', () => tcpSocket.destroy());
+    });
+
+    // Start listening
+    server.listen(port, hostname);
+  });
+}

package/src/resources/assets-helpers.ts

@@ -0,0 +1,63 @@
+import { RequestOptions } from '../internal/request-options';
+import { Assets as GeneratedAssets } from './assets';
+
+export interface AssetGetOrUploadParams {
+  /**
+   * The path to the file to upload.
+   */
+  path: string;
+
+  /**
+   * The name for the asset. Defaults to the name of the file given in the filePath parameter.
+   */
+  name?: string;
+}
+
+export interface AssetGetOrUploadResponse {
+  id: string;
+  name: string;
+  signedDownloadUrl: string;
+  md5: string;
+}
+
+export class Assets extends GeneratedAssets {
+  async getOrUpload(
+    body: AssetGetOrUploadParams,
+    options?: RequestOptions,
+  ): Promise<AssetGetOrUploadResponse> {
+    const { crypto, fs, path } = globalThis as any;
+    const creationResponse = await this.getOrCreate(
+      {
+        name: body.name ?? path.basename(body.path),
+      },
+      options,
+    );
+    const data = await fs.promises.readFile(body.path);
+    const md5 = crypto.createHash('md5').update(data).digest('hex');
+    if (creationResponse.md5 && creationResponse.md5 === md5) {
+      return {
+        id: creationResponse.id,
+        name: creationResponse.name,
+        signedDownloadUrl: creationResponse.signedDownloadUrl,
+        md5: creationResponse.md5,
+      };
+    }
+    const uploadResponse = await fetch(creationResponse.signedUploadUrl, {
+      headers: {
+        'Content-Length': data.length.toString(),
+        'Content-Type': 'application/octet-stream',
+      },
+      method: 'PUT',
+      body: data,
+    });
+    if (uploadResponse.status !== 200) {
+      throw new Error(`Failed to upload asset: ${uploadResponse.status} ${await uploadResponse.text()}`);
+    }
+    return {
+      id: creationResponse.id,
+      name: creationResponse.name,
+      signedDownloadUrl: creationResponse.signedDownloadUrl,
+      md5,
+    };
+  }
+}

package/src/resources/assets.ts

@@ -35,7 +35,7 @@ export class Assets extends APIResource {
    * is no corresponding file in the storage so downloading it directly or using it
    * in instances will fail until you use the returned upload URL to submit the file.
    */
-  getOrCreate(body: AssetGetOrCreateParams, options?: RequestOptions): APIPromise<Asset> {
+  getOrCreate(body: AssetGetOrCreateParams, options?: RequestOptions): APIPromise<AssetGetOrCreateResponse> {
     return this._client.put('/v1/assets', { body, ...options });
   }
 }
@@ -57,6 +57,21 @@ export interface Asset {
 
 export type AssetListResponse = Array<Asset>;
 
+export interface AssetGetOrCreateResponse {
+  id: string;
+
+  name: string;
+
+  signedDownloadUrl: string;
+
+  signedUploadUrl: string;
+
+  /**
+   * Returned only if there is a corresponding file uploaded already.
+   */
+  md5?: string;
+}
+
 export interface AssetListParams {
   /**
    * Toggles whether a download URL should be included in the response
@@ -99,6 +114,7 @@ export declare namespace Assets {
   export {
     type Asset as Asset,
     type AssetListResponse as AssetListResponse,
+    type AssetGetOrCreateResponse as AssetGetOrCreateResponse,
     type AssetListParams as AssetListParams,
     type AssetGetParams as AssetGetParams,
     type AssetGetOrCreateParams as AssetGetOrCreateParams,

package/src/resources/index.ts

@@ -9,10 +9,12 @@ export {
   type AndroidInstanceListParams,
 } from './android-instances';
 export {
-  Assets,
   type Asset,
   type AssetListResponse,
+  type AssetGetOrCreateResponse,
   type AssetListParams,
   type AssetGetParams,
   type AssetGetOrCreateParams,
 } from './assets';
+
+export { Assets, AssetGetOrUploadParams, AssetGetOrUploadResponse } from './assets-helpers';

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.2.0'; // x-release-please-version
+export const VERSION = '0.5.1'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.2.0";
+export declare const VERSION = "0.5.1";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.2.0";
+export declare const VERSION = "0.5.1";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.2.0'; // x-release-please-version
+exports.VERSION = '0.5.1'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.2.0'; // x-release-please-version
+export const VERSION = '0.5.1'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map