playit-reversed 0.1.0-beta.2 → 0.1.0-beta.3

package/dist/cli/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ * Generated at: ${new Date().toISOString()}
+ *
+ * Regenerate with: bun run playit:generate
+ */
+/** All available agent IDs */
+export type AgentId = string;
+/** All available agent names */
+export type AgentName = string;
+/** Agent identifier (property name) */
+export type AgentKey = string;
+/**
+ * Reference to an agent with methods
+ */
+export declare class AgentRef {
+    readonly id: AgentId;
+    readonly name: AgentName;
+    readonly clientIp: string;
+    readonly tunnelIp: string;
+    readonly version: string;
+    readonly os: string;
+    readonly status: string;
+    constructor(id: string, name: string, clientIp: string, tunnelIp: string, version: string, os: string, status: string);
+    /**
+     * Get tunnels for this agent
+     * TODO: Implement when tunnel parsing is ready
+     */
+    getTunnels(): Promise<any[]>;
+    /**
+     * Create a new tunnel for this agent
+     * TODO: Implement when tunnel API is ready
+     */
+    createTunnel(options: {
+        name: string;
+        localPort: number;
+        protocol?: "tcp" | "udp" | "both";
+    }): Promise<void>;
+    /**
+     * Delete this agent
+     * TODO: Implement when agent deletion API is ready
+     */
+    delete(): Promise<void>;
+}

package/dist/cli.js

@@ -611,7 +611,77 @@ var betterFetch = async (url, options) => {
 };
 
 // src/parsers/agents.ts
+function extractRemixContext(html) {
+  const match = html.match(/<script>window\.__remixContext = ([\s\S]*?);<\/script>/);
+  if (!match?.[1])
+    return null;
+  try {
+    return JSON.parse(match[1]);
+  } catch {
+    return null;
+  }
+}
+function parsePlayItHtml(html) {
+  const context = extractRemixContext(html);
+  if (!context) {
+    throw new Error("Could not find Remix context in HTML");
+  }
+  const accountData = context.state.loaderData["routes/account"];
+  const agents = accountData.agents.agents.map((agent) => ({
+    id: agent.id,
+    name: agent.name,
+    clientIp: agent.status.data.client_addr,
+    tunnelIp: agent.status.data.tunnel_addr,
+    version: agent.agent_version.version,
+    os: agent.agent_version.platform,
+    status: agent.status.state
+  }));
+  const tunnels = accountData.tunnels.tunnels.map((tunnel) => ({
+    id: tunnel.id,
+    name: tunnel.name,
+    tunnelType: tunnel.tunnel_type,
+    portType: tunnel.port_type,
+    portCount: tunnel.port_count,
+    alloc: {
+      status: tunnel.alloc.status,
+      id: tunnel.alloc.data.id,
+      ipHostname: tunnel.alloc.data.ip_hostname,
+      staticIp4: tunnel.alloc.data.static_ip4,
+      staticIp6: tunnel.alloc.data.static_ip6,
+      assignedDomain: tunnel.alloc.data.assigned_domain,
+      assignedSrv: tunnel.alloc.data.assigned_srv,
+      tunnelIp: tunnel.alloc.data.tunnel_ip,
+      portStart: tunnel.alloc.data.port_start,
+      portEnd: tunnel.alloc.data.port_end,
+      ipType: tunnel.alloc.data.ip_type,
+      region: tunnel.alloc.data.region
+    },
+    origin: {
+      agentId: tunnel.origin.data.agent_id,
+      agentName: tunnel.origin.data.agent_name,
+      localIp: tunnel.origin.data.local_ip,
+      localPort: tunnel.origin.data.local_port
+    },
+    domain: tunnel.domain,
+    active: tunnel.active,
+    region: tunnel.region,
+    proxyProtocol: tunnel.proxy_protocol
+  }));
+  return { agents, tunnels };
+}
 function parseAgentsHtml(html) {
+  const context = extractRemixContext(html);
+  if (context) {
+    return context.state.loaderData["routes/account"].agents.agents.map((agent) => ({
+      id: agent.id,
+      name: agent.name,
+      clientIp: agent.status.data.client_addr,
+      tunnelIp: agent.status.data.tunnel_addr,
+      version: agent.agent_version.version,
+      os: agent.agent_version.platform,
+      status: agent.status.state
+    }));
+  }
   const table = html.match(/<table class="row-links with-spacing">[\s\S]*?<\/table>/)?.[0];
   if (!table) {
     throw new Error("No table found in HTML");
@@ -622,6 +692,43 @@ function parseAgentsHtml(html) {
   }
   return rows.map(parseAgentRow);
 }
+function parseTunnelsHtml(html) {
+  const context = extractRemixContext(html);
+  if (!context) {
+    throw new Error("Could not find Remix context in HTML");
+  }
+  return context.state.loaderData["routes/account"].tunnels.tunnels.map((tunnel) => ({
+    id: tunnel.id,
+    name: tunnel.name,
+    tunnelType: tunnel.tunnel_type,
+    portType: tunnel.port_type,
+    portCount: tunnel.port_count,
+    alloc: {
+      status: tunnel.alloc.status,
+      id: tunnel.alloc.data.id,
+      ipHostname: tunnel.alloc.data.ip_hostname,
+      staticIp4: tunnel.alloc.data.static_ip4,
+      staticIp6: tunnel.alloc.data.static_ip6,
+      assignedDomain: tunnel.alloc.data.assigned_domain,
+      assignedSrv: tunnel.alloc.data.assigned_srv,
+      tunnelIp: tunnel.alloc.data.tunnel_ip,
+      portStart: tunnel.alloc.data.port_start,
+      portEnd: tunnel.alloc.data.port_end,
+      ipType: tunnel.alloc.data.ip_type,
+      region: tunnel.alloc.data.region
+    },
+    origin: {
+      agentId: tunnel.origin.data.agent_id,
+      agentName: tunnel.origin.data.agent_name,
+      localIp: tunnel.origin.data.local_ip,
+      localPort: tunnel.origin.data.local_port
+    },
+    domain: tunnel.domain,
+    active: tunnel.active,
+    region: tunnel.region,
+    proxyProtocol: tunnel.proxy_protocol
+  }));
+}
 function parseAgentRow(row) {
   const id = row.match(/href="\/account\/agents\/([a-f0-9-]+)"/)?.[1] ?? "";
   const name = row.match(/<td[^>]*><a[^>]*>([^<]+)<span/)?.[1]?.trim() ?? "";
@@ -14265,12 +14372,12 @@ class PlayIt {
     }
     return new PlayIt(options);
   }
-  async fetchAgents() {
+  async fetchAll() {
     const { data, error: error48 } = await this.$fetch("/account/agents");
     if (error48) {
-      throw new Error("Failed to get agents: " + error48.message);
+      throw new Error("Failed to fetch PlayIt data: " + error48.message);
     }
-    return parseAgentsHtml(data);
+    return parsePlayItHtml(data);
   }
 }
 
@@ -14334,60 +14441,126 @@ async function setup() {
     console.log(`✓ Token found
 `);
   }
-  console.log("Fetching agents from PlayIt...");
+  console.log("Fetching data from PlayIt...");
   const client = PlayIt.create({
     authorizationToken: token,
     _skipCodegenCheck: true
   });
   try {
-    const agents = await client.fetchAgents();
-    console.log(`✓ Found ${agents.length} agent(s)
-`);
-    for (const agent of agents) {
-      console.log(`  • ${agent.name} (${agent.status})`);
+    const data = await client.fetchAll();
+    console.log(`✓ Found ${data.agents.length} agent(s)`);
+    for (const agent of data.agents) {
+      const agentTunnels = data.tunnels.filter((t) => t.origin.agentId === agent.id);
+      console.log(`  • ${agent.name} (${agent.status}) - ${agentTunnels.length} tunnel(s)`);
     }
-    console.log();
-    fs2.writeFileSync(DATA_FILE, JSON.stringify({ agents, updatedAt: new Date().toISOString() }, null, 2));
-    await generateTypes(agents);
+    console.log(`
+✓ Found ${data.tunnels.length} tunnel(s)`);
+    for (const tunnel of data.tunnels) {
+      console.log(`  • ${tunnel.name} (${tunnel.portType}) → ${tunnel.origin.localIp}:${tunnel.origin.localPort}`);
+    }
+    fs2.writeFileSync(DATA_FILE, JSON.stringify({
+      ...data,
+      updatedAt: new Date().toISOString()
+    }, null, 2));
+    await generateTypes(data);
     console.log(`
 ✅ Setup complete!
 `);
     console.log("Usage:");
     console.log(`  import { playit } from "./generated/playit";
 `);
+    console.log("  // Access agents");
     console.log("  const agent = playit.agents.capaodocorvo_srv;");
-    console.log(`  console.log(agent.id, agent.status);
+    console.log(`  console.log(agent.tunnels);
+`);
+    console.log("  // Access tunnels directly");
+    console.log("  const tunnel = playit.tunnels.SSH;");
+    console.log(`  console.log(tunnel.alloc.assignedDomain);
 `);
   } catch (error48) {
-    console.error("❌ Failed to fetch agents:", error48);
+    console.error("❌ Failed to fetch data:", error48);
     process.exit(1);
   }
 }
-async function generateTypes(agents) {
-  if (!agents) {
+async function generateTypes(data) {
+  if (!data) {
     if (!fs2.existsSync(DATA_FILE)) {
       console.error("❌ No data found. Run 'bun run playit:setup' first.");
       process.exit(1);
     }
-    const data = JSON.parse(fs2.readFileSync(DATA_FILE, "utf-8"));
-    agents = data.agents;
+    data = JSON.parse(fs2.readFileSync(DATA_FILE, "utf-8"));
   }
+  const { agents, tunnels } = data;
   if (!agents || agents.length === 0) {
     console.error("❌ No agents found");
     process.exit(1);
   }
   const toIdentifier = (name) => name.replace(/[^a-zA-Z0-9]/g, "_");
+  const tunnelKeyCounts = new Map;
+  const getTunnelKey = (name) => {
+    const base = toIdentifier(name);
+    const count = tunnelKeyCounts.get(base) || 0;
+    tunnelKeyCounts.set(base, count + 1);
+    return count === 0 ? base : `${base}_${count + 1}`;
+  };
+  const tunnelKeys = tunnels.map((t) => getTunnelKey(t.name));
   const agentIds = agents.map((a) => `"${a.id}"`).join(" | ");
   const agentNames = agents.map((a) => `"${a.name}"`).join(" | ");
-  const agentEntries = agents.map((a) => `    "${a.name}": "${a.id}"`).join(`,
+  const agentKeys = agents.map((a) => `"${toIdentifier(a.name)}"`).join(" | ");
+  const tunnelIds = tunnels.length > 0 ? tunnels.map((t) => `"${t.id}"`).join(" | ") : "never";
+  const tunnelNames = tunnels.length > 0 ? [...new Set(tunnels.map((t) => `"${t.name}"`))].join(" | ") : "never";
+  const tunnelKeyTypes = tunnels.length > 0 ? tunnelKeys.map((k) => `"${k}"`).join(" | ") : "never";
+  const tunnelInstances = tunnels.map((t, i) => `    ${tunnelKeys[i]}: {
+        id: "${t.id}" as const,
+        name: "${t.name}" as const,
+        tunnelType: ${t.tunnelType ? `"${t.tunnelType}"` : "null"},
+        portType: "${t.portType}" as const,
+        portCount: ${t.portCount},
+        alloc: {
+            status: "${t.alloc.status}",
+            id: "${t.alloc.id}",
+            ipHostname: "${t.alloc.ipHostname}",
+            staticIp4: "${t.alloc.staticIp4}",
+            staticIp6: "${t.alloc.staticIp6}",
+            assignedDomain: "${t.alloc.assignedDomain}",
+            assignedSrv: ${t.alloc.assignedSrv ? `"${t.alloc.assignedSrv}"` : "null"},
+            tunnelIp: "${t.alloc.tunnelIp}",
+            portStart: ${t.alloc.portStart},
+            portEnd: ${t.alloc.portEnd},
+            ipType: "${t.alloc.ipType}",
+            region: "${t.alloc.region}",
+        },
+        origin: {
+            agentId: "${t.origin.agentId}" as AgentId,
+            agentName: "${t.origin.agentName}" as AgentName,
+            localIp: "${t.origin.localIp}",
+            localPort: ${t.origin.localPort},
+        },
+        domain: ${t.domain ? `"${t.domain}"` : "null"},
+        active: ${t.active},
+        region: "${t.region}",
+        proxyProtocol: ${t.proxyProtocol ? `"${t.proxyProtocol}"` : "null"},
+    }`).join(`,
 `);
-  const agentInstances = agents.map((a) => `    ${toIdentifier(a.name)}: new AgentRef("${a.id}", "${a.name}", "${a.clientIp}", "${a.tunnelIp}", "${a.version}", "${a.os}", "${a.status}")`).join(`,
+  const agentInstances = agents.map((a) => {
+    const agentTunnelRefs = tunnels.map((t, i) => ({ tunnel: t, key: tunnelKeys[i] })).filter(({ tunnel }) => tunnel.origin.agentId === a.id).map(({ key }) => `tunnels.${key}`).join(", ");
+    return `    ${toIdentifier(a.name)}: {
+        id: "${a.id}" as const,
+        name: "${a.name}" as const,
+        clientIp: "${a.clientIp}",
+        tunnelIp: "${a.tunnelIp}",
+        version: "${a.version}",
+        os: "${a.os}" as const,
+        status: "${a.status}" as const,
+        tunnels: [${agentTunnelRefs}] as const,
+    }`;
+  }).join(`,
 `);
   const content = `/**
  * AUTO-GENERATED FILE - DO NOT EDIT
  * Generated at: ${new Date().toISOString()}
  * 
- * Regenerate with: bun run playit:generate
+ * Regenerate with: bun run playit:setup
  */
 
 import { spawn } from "child_process";
@@ -14401,82 +14574,41 @@ export type AgentId = ${agentIds};
 export type AgentName = ${agentNames};
 
 /** Agent identifier (property name) */
-export type AgentKey = ${agents.map((a) => `"${toIdentifier(a.name)}"`).join(" | ")};
+export type AgentKey = ${agentKeys};
 
-// ============ Agent Reference ============
+/** All available tunnel IDs */
+export type TunnelId = ${tunnelIds};
 
-/**
- * Reference to an agent with methods
- */
-export class AgentRef {
-    readonly id: AgentId;
-    readonly name: AgentName;
-    readonly clientIp: string;
-    readonly tunnelIp: string;
-    readonly version: string;
-    readonly os: string;
-    readonly status: string;
+/** All available tunnel names */
+export type TunnelName = ${tunnelNames};
 
-    constructor(
-        id: string,
-        name: string,
-        clientIp: string,
-        tunnelIp: string,
-        version: string,
-        os: string,
-        status: string
-    ) {
-        this.id = id as AgentId;
-        this.name = name as AgentName;
-        this.clientIp = clientIp;
-        this.tunnelIp = tunnelIp;
-        this.version = version;
-        this.os = os;
-        this.status = status;
-    }
+/** Tunnel identifier (property name) */
+export type TunnelKey = ${tunnelKeyTypes};
 
-    /**
-     * Get tunnels for this agent
-     * TODO: Implement when tunnel parsing is ready
-     */
-    async getTunnels(): Promise<any[]> {
-        // TODO: Implement tunnel fetching
-        throw new Error("Not implemented yet - tunnels coming soon");
-    }
+// ============ Tunnels ============
 
-    /**
-     * Create a new tunnel for this agent
-     * TODO: Implement when tunnel API is ready
-     */
-    async createTunnel(options: {
-        name: string;
-        localPort: number;
-        protocol?: "tcp" | "udp" | "both";
-    }): Promise<void> {
-        // TODO: Implement tunnel creation
-        throw new Error("Not implemented yet - tunnels coming soon");
-    }
+/** All tunnels (statically typed) */
+export const tunnels = {
+${tunnelInstances}
+} as const;
 
-    /**
-     * Delete this agent
-     * TODO: Implement when agent deletion API is ready
-     */
-    async delete(): Promise<void> {
-        // TODO: Implement agent deletion
-        throw new Error("Not implemented yet");
-    }
-}
+/** Array of all tunnel IDs */
+export const ALL_TUNNEL_IDS: TunnelId[] = [${tunnels.map((t) => `"${t.id}"`).join(", ")}];
+
+/** Array of all tunnel names */
+export const ALL_TUNNEL_NAMES: TunnelName[] = [${tunnels.map((t) => `"${t.name}"`).join(", ")}];
 
 // ============ Agents ============
 
-/** All agents (statically typed with methods) */
+/** All agents (statically typed with their tunnels) */
 export const agents = {
 ${agentInstances}
 } as const;
 
 /** Map of agent names to IDs */
 export const AGENT_IDS = {
-${agentEntries}
+${agents.map((a) => `    "${a.name}": "${a.id}"`).join(`,
+`)}
 } as const;
 
 /** Array of all agent IDs */
@@ -14489,7 +14621,6 @@ export const ALL_AGENT_NAMES: AgentName[] = [${agents.map((a) => `"${a.name}"`).
 
 /**
  * Regenerate types by re-fetching from PlayIt API
- * This runs the codegen CLI
  */
 export async function regenerate(): Promise<void> {
     return new Promise((resolve, reject) => {
@@ -14518,29 +14649,40 @@ export async function regenerate(): Promise<void> {
  * \`\`\`ts
  * import { playit } from "./generated/playit";
  * 
- * // Access agents directly (fully typed with methods!)
+ * // Access agents (with their tunnels)
  * const agent = playit.agents.${toIdentifier(agents[0]?.name || "my_agent")};
- * console.log(agent.id);     // "${agents[0]?.id || "..."}"
- * console.log(agent.status); // "${agents[0]?.status || "..."}"
+ * console.log(agent.id);       // "${agents[0]?.id || "..."}"
+ * console.log(agent.status);   // "${agents[0]?.status || "..."}"
+ * console.log(agent.tunnels);  // All tunnels for this agent
  * 
- * // Agent methods (coming soon)
- * // const tunnels = await agent.getTunnels();
- * // await agent.createTunnel({ name: "SSH", localPort: 22 });
+ * // Access tunnels directly
+ * const tunnel = playit.tunnels.${toIdentifier(tunnels[0]?.name || "my_tunnel")};
+ * console.log(tunnel.alloc.assignedDomain);
+ * console.log(tunnel.origin.localPort);
  * 
  * // Regenerate types after changes
  * await playit.regenerate();
  * \`\`\`
  */
 export const playit = {
-    /** All agents (statically typed with methods) */
+    /** All agents (with their tunnels) */
     agents,
     
+    /** All tunnels */
+    tunnels,
+    
     /** All agent IDs */
     agentIds: ALL_AGENT_IDS,
     
     /** All agent names */
     agentNames: ALL_AGENT_NAMES,
     
+    /** All tunnel IDs */
+    tunnelIds: ALL_TUNNEL_IDS,
+    
+    /** All tunnel names */
+    tunnelNames: ALL_TUNNEL_NAMES,
+    
     /** Regenerate types after changes */
     regenerate,
 };
@@ -14552,7 +14694,8 @@ export default playit;
   }
   const outputPath = path2.join(GENERATED_DIR, "playit.ts");
   fs2.writeFileSync(outputPath, content);
-  console.log(`✓ Generated types at ${outputPath}`);
+  console.log(`
+✓ Generated types at ${outputPath}`);
 }
 var command = process.argv[2];
 switch (command) {

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { Agent, PlayItOptions } from "./types";
+import type { PlayItOptions, PlayItData } from "./types";
 /**
  * PlayIt.gg API client
  *
@@ -19,7 +19,7 @@ export declare class PlayIt<TAgentId extends string = string, TAgentName extends
         _skipCodegenCheck?: boolean;
     }): PlayIt<TAgentId, TAgentName>;
     /**
-     * Fetch all agents from the API
+     * Fetch all data from PlayIt (agents + tunnels) in a single request
      */
-    fetchAgents(): Promise<Agent[]>;
+    fetchAll(): Promise<PlayItData>;
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import "dotenv/config";
 export { PlayIt } from "./client";
 export { PlayIt as default } from "./client";
-export type { Agent, Tunnel, PlayItOptions } from "./types";
-export { parseAgentsHtml } from "./parsers";
+export type { Agent, Tunnel, TunnelAlloc, TunnelOrigin, PlayItOptions, PlayItData } from "./types";
+export { parsePlayItHtml, parseAgentsHtml, parseTunnelsHtml } from "./parsers";
 export { requireCodegen, isCodegenComplete, CodegenRequiredError } from "./guard";

package/dist/index.js

@@ -1052,7 +1052,77 @@ var betterFetch = async (url, options) => {
 };
 
 // src/parsers/agents.ts
+function extractRemixContext(html) {
+  const match = html.match(/<script>window\.__remixContext = ([\s\S]*?);<\/script>/);
+  if (!match?.[1])
+    return null;
+  try {
+    return JSON.parse(match[1]);
+  } catch {
+    return null;
+  }
+}
+function parsePlayItHtml(html) {
+  const context = extractRemixContext(html);
+  if (!context) {
+    throw new Error("Could not find Remix context in HTML");
+  }
+  const accountData = context.state.loaderData["routes/account"];
+  const agents = accountData.agents.agents.map((agent) => ({
+    id: agent.id,
+    name: agent.name,
+    clientIp: agent.status.data.client_addr,
+    tunnelIp: agent.status.data.tunnel_addr,
+    version: agent.agent_version.version,
+    os: agent.agent_version.platform,
+    status: agent.status.state
+  }));
+  const tunnels = accountData.tunnels.tunnels.map((tunnel) => ({
+    id: tunnel.id,
+    name: tunnel.name,
+    tunnelType: tunnel.tunnel_type,
+    portType: tunnel.port_type,
+    portCount: tunnel.port_count,
+    alloc: {
+      status: tunnel.alloc.status,
+      id: tunnel.alloc.data.id,
+      ipHostname: tunnel.alloc.data.ip_hostname,
+      staticIp4: tunnel.alloc.data.static_ip4,
+      staticIp6: tunnel.alloc.data.static_ip6,
+      assignedDomain: tunnel.alloc.data.assigned_domain,
+      assignedSrv: tunnel.alloc.data.assigned_srv,
+      tunnelIp: tunnel.alloc.data.tunnel_ip,
+      portStart: tunnel.alloc.data.port_start,
+      portEnd: tunnel.alloc.data.port_end,
+      ipType: tunnel.alloc.data.ip_type,
+      region: tunnel.alloc.data.region
+    },
+    origin: {
+      agentId: tunnel.origin.data.agent_id,
+      agentName: tunnel.origin.data.agent_name,
+      localIp: tunnel.origin.data.local_ip,
+      localPort: tunnel.origin.data.local_port
+    },
+    domain: tunnel.domain,
+    active: tunnel.active,
+    region: tunnel.region,
+    proxyProtocol: tunnel.proxy_protocol
+  }));
+  return { agents, tunnels };
+}
 function parseAgentsHtml(html) {
+  const context = extractRemixContext(html);
+  if (context) {
+    return context.state.loaderData["routes/account"].agents.agents.map((agent) => ({
+      id: agent.id,
+      name: agent.name,
+      clientIp: agent.status.data.client_addr,
+      tunnelIp: agent.status.data.tunnel_addr,
+      version: agent.agent_version.version,
+      os: agent.agent_version.platform,
+      status: agent.status.state
+    }));
+  }
   const table = html.match(/<table class="row-links with-spacing">[\s\S]*?<\/table>/)?.[0];
   if (!table) {
     throw new Error("No table found in HTML");
@@ -1063,6 +1133,43 @@ function parseAgentsHtml(html) {
   }
   return rows.map(parseAgentRow);
 }
+function parseTunnelsHtml(html) {
+  const context = extractRemixContext(html);
+  if (!context) {
+    throw new Error("Could not find Remix context in HTML");
+  }
+  return context.state.loaderData["routes/account"].tunnels.tunnels.map((tunnel) => ({
+    id: tunnel.id,
+    name: tunnel.name,
+    tunnelType: tunnel.tunnel_type,
+    portType: tunnel.port_type,
+    portCount: tunnel.port_count,
+    alloc: {
+      status: tunnel.alloc.status,
+      id: tunnel.alloc.data.id,
+      ipHostname: tunnel.alloc.data.ip_hostname,
+      staticIp4: tunnel.alloc.data.static_ip4,
+      staticIp6: tunnel.alloc.data.static_ip6,
+      assignedDomain: tunnel.alloc.data.assigned_domain,
+      assignedSrv: tunnel.alloc.data.assigned_srv,
+      tunnelIp: tunnel.alloc.data.tunnel_ip,
+      portStart: tunnel.alloc.data.port_start,
+      portEnd: tunnel.alloc.data.port_end,
+      ipType: tunnel.alloc.data.ip_type,
+      region: tunnel.alloc.data.region
+    },
+    origin: {
+      agentId: tunnel.origin.data.agent_id,
+      agentName: tunnel.origin.data.agent_name,
+      localIp: tunnel.origin.data.local_ip,
+      localPort: tunnel.origin.data.local_port
+    },
+    domain: tunnel.domain,
+    active: tunnel.active,
+    region: tunnel.region,
+    proxyProtocol: tunnel.proxy_protocol
+  }));
+}
 function parseAgentRow(row) {
   const id = row.match(/href="\/account\/agents\/([a-f0-9-]+)"/)?.[1] ?? "";
   const name = row.match(/<td[^>]*><a[^>]*>([^<]+)<span/)?.[1]?.trim() ?? "";
@@ -14706,16 +14813,18 @@ class PlayIt {
     }
     return new PlayIt(options);
   }
-  async fetchAgents() {
+  async fetchAll() {
     const { data, error: error48 } = await this.$fetch("/account/agents");
     if (error48) {
-      throw new Error("Failed to get agents: " + error48.message);
+      throw new Error("Failed to fetch PlayIt data: " + error48.message);
     }
-    return parseAgentsHtml(data);
+    return parsePlayItHtml(data);
   }
 }
 export {
   requireCodegen,
+  parseTunnelsHtml,
+  parsePlayItHtml,
   parseAgentsHtml,
   isCodegenComplete,
   PlayIt as default,

package/dist/parsers/agents.d.ts

@@ -1,5 +1,15 @@
-import type { Agent } from "../types";
+import type { Agent, Tunnel, PlayItData } from "../types";
+/**
+ * Parse all data from the PlayIt HTML page (agents + tunnels)
+ */
+export declare function parsePlayItHtml(html: string): PlayItData;
 /**
  * Parse the agents HTML page and extract agent data
+ * @deprecated Use parsePlayItHtml instead
  */
 export declare function parseAgentsHtml(html: string): Agent[];
+/**
+ * Parse tunnels from HTML
+ * @deprecated Use parsePlayItHtml instead
+ */
+export declare function parseTunnelsHtml(html: string): Tunnel[];

package/dist/parsers/index.d.ts

@@ -1 +1 @@
-export { parseAgentsHtml } from "./agents";
+export { parsePlayItHtml, parseAgentsHtml, parseTunnelsHtml } from "./agents";

package/dist/types.d.ts

@@ -7,8 +7,38 @@ export interface Agent {
     os: string;
     status: string;
 }
+export interface TunnelAlloc {
+    status: string;
+    id: string;
+    ipHostname: string;
+    staticIp4: string;
+    staticIp6: string;
+    assignedDomain: string;
+    assignedSrv: string | null;
+    tunnelIp: string;
+    portStart: number;
+    portEnd: number;
+    ipType: string;
+    region: string;
+}
+export interface TunnelOrigin {
+    agentId: string;
+    agentName: string;
+    localIp: string;
+    localPort: number;
+}
 export interface Tunnel {
     id: string;
+    name: string;
+    tunnelType: string | null;
+    portType: string;
+    portCount: number;
+    alloc: TunnelAlloc;
+    origin: TunnelOrigin;
+    domain: string | null;
+    active: boolean;
+    region: string;
+    proxyProtocol: string | null;
 }
 export interface PlayItOptions {
     /** Your playit.gg session token */
@@ -16,3 +46,7 @@ export interface PlayItOptions {
     /** Base URL for the API (default: https://playit.gg) */
     baseUrl?: string;
 }
+export interface PlayItData {
+    agents: Agent[];
+    tunnels: Tunnel[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playit-reversed",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.3",
   "author": {
     "name": "Cete",
     "email": "tocka@tockanest.ch",
@@ -52,4 +52,4 @@
     "client"
   ],
   "license": "MIT"
-}
+}