@elizaos/plugin-tailscale 2.0.0-beta.1 → 2.0.11-beta.7

package/dist/index.js

@@ -1,902 +0,0 @@
-// src/index.ts
-import {
-  elizaLogger as elizaLogger4,
-  getConnectorAccountManager
-} from "@elizaos/core";
-import { tunnelSlotIsFree } from "@elizaos/plugin-tunnel";
-
-// src/services/CloudTailscaleService.ts
-import { spawn } from "child_process";
-import { elizaLogger, Service } from "@elizaos/core";
-import { z as z2 } from "zod";
-
-// src/accounts.ts
-var DEFAULT_TAILSCALE_ACCOUNT_ID = "default";
-function nonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-}
-function readSetting(runtime, key) {
-  return nonEmptyString(runtime.getSetting(key));
-}
-function normalizeTailscaleAccountId(value) {
-  return nonEmptyString(value) ?? DEFAULT_TAILSCALE_ACCOUNT_ID;
-}
-function resolveTailscaleAccountId(runtime, options) {
-  return normalizeTailscaleAccountId(
-    options?.accountId ?? options?.tailscaleAccountId ?? readSetting(runtime, "TAILSCALE_DEFAULT_ACCOUNT_ID") ?? readSetting(runtime, "TAILSCALE_ACCOUNT_ID")
-  );
-}
-function parseAccountsJson(raw) {
-  if (!raw) return [];
-  try {
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed)) {
-      return parsed.filter(
-        (item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)
-      );
-    }
-    if (parsed && typeof parsed === "object") {
-      return Object.entries(parsed).filter(([, value]) => value && typeof value === "object").map(([id, value]) => ({
-        ...value,
-        accountId: value.accountId ?? id
-      }));
-    }
-  } catch {
-    return [];
-  }
-  return [];
-}
-function readRawField(record, keys) {
-  const credentials = record.credentials && typeof record.credentials === "object" ? record.credentials : {};
-  const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
-  const settings = record.settings && typeof record.settings === "object" ? record.settings : {};
-  for (const source of [record, credentials, metadata, settings]) {
-    for (const key of keys) {
-      const value = source[key];
-      if (value !== void 0 && value !== null && value !== "") return value;
-    }
-  }
-  return void 0;
-}
-function normalizeBackend(value) {
-  return value === "local" || value === "cloud" || value === "auto" ? value : void 0;
-}
-function accountFromRecord(record) {
-  const accountId = normalizeTailscaleAccountId(
-    record.accountId ?? record.id ?? record.name
-  );
-  const account = {
-    accountId,
-    authKey: nonEmptyString(
-      readRawField(record, [
-        "TAILSCALE_AUTH_KEY",
-        "authKey",
-        "accessToken",
-        "access"
-      ])
-    ),
-    tags: readRawField(record, ["TAILSCALE_TAGS", "tags"]),
-    funnel: readRawField(record, ["TAILSCALE_FUNNEL", "funnel"]),
-    defaultPort: readRawField(record, [
-      "TAILSCALE_DEFAULT_PORT",
-      "defaultPort"
-    ]),
-    backend: normalizeBackend(
-      readRawField(record, ["TAILSCALE_BACKEND", "backend"])
-    ),
-    authKeyExpirySeconds: readRawField(record, [
-      "TAILSCALE_AUTH_KEY_EXPIRY_SECONDS",
-      "authKeyExpirySeconds"
-    ]),
-    cloudApiKey: nonEmptyString(
-      readRawField(record, ["ELIZAOS_CLOUD_API_KEY", "cloudApiKey"])
-    ),
-    cloudBaseUrl: nonEmptyString(
-      readRawField(record, ["ELIZAOS_CLOUD_BASE_URL", "cloudBaseUrl"])
-    ),
-    label: nonEmptyString(record.label ?? record.displayName)
-  };
-  return account;
-}
-function addAccount(accounts, account) {
-  if (account) {
-    accounts.set(account.accountId, account);
-  }
-}
-function readTailscaleAccounts(runtime) {
-  const accounts = /* @__PURE__ */ new Map();
-  const characterConfig = runtime.character?.settings?.tailscale;
-  const characterAccounts = characterConfig?.accounts;
-  if (Array.isArray(characterAccounts)) {
-    for (const item of characterAccounts) {
-      if (item && typeof item === "object") {
-        addAccount(accounts, accountFromRecord(item));
-      }
-    }
-  } else if (characterAccounts && typeof characterAccounts === "object") {
-    for (const [id, value] of Object.entries(
-      characterAccounts
-    )) {
-      if (value && typeof value === "object") {
-        addAccount(
-          accounts,
-          accountFromRecord({
-            ...value,
-            accountId: value.accountId ?? id
-          })
-        );
-      }
-    }
-  }
-  for (const record of parseAccountsJson(
-    readSetting(runtime, "TAILSCALE_ACCOUNTS")
-  )) {
-    addAccount(accounts, accountFromRecord(record));
-  }
-  addAccount(accounts, {
-    accountId: normalizeTailscaleAccountId(
-      readSetting(runtime, "TAILSCALE_ACCOUNT_ID") ?? readSetting(runtime, "TAILSCALE_DEFAULT_ACCOUNT_ID")
-    ),
-    authKey: readSetting(runtime, "TAILSCALE_AUTH_KEY"),
-    tags: readSetting(runtime, "TAILSCALE_TAGS"),
-    funnel: readSetting(runtime, "TAILSCALE_FUNNEL"),
-    defaultPort: readSetting(runtime, "TAILSCALE_DEFAULT_PORT"),
-    backend: normalizeBackend(readSetting(runtime, "TAILSCALE_BACKEND")),
-    authKeyExpirySeconds: readSetting(
-      runtime,
-      "TAILSCALE_AUTH_KEY_EXPIRY_SECONDS"
-    ),
-    cloudApiKey: readSetting(runtime, "ELIZAOS_CLOUD_API_KEY"),
-    cloudBaseUrl: readSetting(runtime, "ELIZAOS_CLOUD_BASE_URL")
-  });
-  return Array.from(accounts.values());
-}
-function resolveTailscaleAccount(accounts, accountId) {
-  return accounts.find((account) => account.accountId === accountId) ?? accounts.find(
-    (account) => account.accountId === DEFAULT_TAILSCALE_ACCOUNT_ID
-  ) ?? accounts[0] ?? null;
-}
-
-// src/environment.ts
-import { z } from "zod";
-var tailscaleEnvSchema = z.object({
-  TAILSCALE_AUTH_KEY: z.string().optional(),
-  TAILSCALE_TAGS: z.union([z.string(), z.array(z.string())]).optional().transform((value) => {
-    if (Array.isArray(value)) return value.filter((tag) => tag.length > 0);
-    if (typeof value === "string" && value.length > 0)
-      return value.split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
-    return ["tag:eliza-tunnel"];
-  }).default(["tag:eliza-tunnel"]),
-  TAILSCALE_FUNNEL: z.union([z.string(), z.boolean()]).optional().transform((value) => value === true || value === "true" || value === "1").default(false),
-  TAILSCALE_DEFAULT_PORT: z.union([z.string(), z.number()]).optional().transform((value) => {
-    if (value === void 0 || value === "") return 3e3;
-    const num = typeof value === "string" ? Number.parseInt(value, 10) : value;
-    if (Number.isNaN(num) || num <= 0 || num > 65535) return 3e3;
-    return num;
-  }).default(3e3),
-  TAILSCALE_BACKEND: z.enum(["local", "cloud", "auto"]).optional().default("auto"),
-  TAILSCALE_AUTH_KEY_EXPIRY_SECONDS: z.union([z.string(), z.number()]).optional().transform((value) => {
-    if (value === void 0 || value === "") return 3600;
-    const num = typeof value === "string" ? Number.parseInt(value, 10) : value;
-    if (Number.isNaN(num) || num <= 0) return 3600;
-    return num;
-  }).default(3600)
-});
-function readSetting2(runtime, key) {
-  const value = runtime.getSetting(key);
-  if (value === null || value === void 0) return void 0;
-  return String(value);
-}
-async function validateTailscaleConfig(runtime, accountId) {
-  const resolvedAccountId = accountId ?? resolveTailscaleAccountId(runtime);
-  const account = resolveTailscaleAccount(
-    readTailscaleAccounts(runtime),
-    resolvedAccountId
-  );
-  const config = {
-    TAILSCALE_AUTH_KEY: account?.authKey ?? readSetting2(runtime, "TAILSCALE_AUTH_KEY") ?? process.env.TAILSCALE_AUTH_KEY,
-    TAILSCALE_TAGS: account?.tags ?? readSetting2(runtime, "TAILSCALE_TAGS") ?? process.env.TAILSCALE_TAGS,
-    TAILSCALE_FUNNEL: account?.funnel ?? readSetting2(runtime, "TAILSCALE_FUNNEL") ?? process.env.TAILSCALE_FUNNEL,
-    TAILSCALE_DEFAULT_PORT: account?.defaultPort ?? readSetting2(runtime, "TAILSCALE_DEFAULT_PORT") ?? process.env.TAILSCALE_DEFAULT_PORT,
-    TAILSCALE_BACKEND: account?.backend ?? readSetting2(runtime, "TAILSCALE_BACKEND") ?? process.env.TAILSCALE_BACKEND,
-    TAILSCALE_AUTH_KEY_EXPIRY_SECONDS: account?.authKeyExpirySeconds ?? readSetting2(runtime, "TAILSCALE_AUTH_KEY_EXPIRY_SECONDS") ?? process.env.TAILSCALE_AUTH_KEY_EXPIRY_SECONDS
-  };
-  return tailscaleEnvSchema.parse(config);
-}
-
-// src/services/CloudTailscaleService.ts
-var CLOUD_BASE_FALLBACK = "https://api.elizacloud.ai/api/v1";
-var authKeyResponseSchema = z2.object({
-  authKey: z2.string(),
-  tailnet: z2.string(),
-  loginServer: z2.string().optional(),
-  hostname: z2.string().optional(),
-  magicDnsName: z2.string()
-});
-function defaultCliRunner(cmd, args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
-    const out = [];
-    const err = [];
-    child.stdout?.on("data", (chunk) => out.push(chunk));
-    child.stderr?.on("data", (chunk) => err.push(chunk));
-    child.on("error", reject);
-    child.on(
-      "exit",
-      (code) => resolve({
-        code,
-        stdout: Buffer.concat(out).toString("utf8"),
-        stderr: Buffer.concat(err).toString("utf8")
-      })
-    );
-  });
-}
-async function defaultFetch(url, init) {
-  return normalizeFetchResponse(await fetch(url, init));
-}
-var CloudTailscaleService = class _CloudTailscaleService extends Service {
-  static serviceType = "tunnel";
-  capabilityDescription = "Provides Tailscale tunnel functionality via Eliza Cloud \u2014 auth keys are minted server-side and the local CLI joins the tailnet.";
-  fetchImpl;
-  cliRunner;
-  tunnelUrl = null;
-  tunnelPort = null;
-  startedAt = null;
-  isShuttingDown = false;
-  joinedTailnet = false;
-  constructor(runtime, options = {}) {
-    super(runtime);
-    this.fetchImpl = options.fetch ?? defaultFetch;
-    this.cliRunner = options.cliRunner ?? defaultCliRunner;
-  }
-  static async start(runtime) {
-    const service = new _CloudTailscaleService(runtime);
-    await service.start();
-    return service;
-  }
-  async start() {
-    elizaLogger.info("[CloudTailscaleService] started");
-  }
-  async stop() {
-    await this.stopTunnel();
-  }
-  async startTunnel(port, options = {}) {
-    if (this.isActive()) {
-      elizaLogger.warn("[CloudTailscaleService] tunnel already running");
-      return this.tunnelUrl ?? void 0;
-    }
-    if (port === void 0 || port === null) {
-      elizaLogger.warn(
-        "[CloudTailscaleService] startTunnel called without a port \u2014 service active but no tunnel started"
-      );
-      return;
-    }
-    if (port < 1 || port > 65535) {
-      throw new Error("Invalid port number");
-    }
-    const config = await validateTailscaleConfig(
-      this.runtime,
-      options.accountId
-    );
-    const { baseUrl, apiKey } = this.resolveCloudCredentials(options.accountId);
-    const response = await this.fetchImpl(
-      `${baseUrl}/apis/tunnels/tailscale/auth-key`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify({
-          tags: config.TAILSCALE_TAGS,
-          expirySeconds: config.TAILSCALE_AUTH_KEY_EXPIRY_SECONDS
-        })
-      }
-    );
-    if (!response.ok) {
-      const text = await safeReadText(response);
-      throw new Error(
-        `Cloud Tailscale auth-key mint failed (${response.status} ${response.statusText}): ${text}`
-      );
-    }
-    const rawJson = await response.json();
-    const parsed = authKeyResponseSchema.safeParse(rawJson);
-    if (!parsed.success) {
-      throw new Error(
-        `Cloud Tailscale response malformed: ${parsed.error.issues.map((i) => i.message).join("; ")}`
-      );
-    }
-    await this.joinTailnet(parsed.data);
-    await this.runServe(port, config.TAILSCALE_FUNNEL);
-    this.tunnelUrl = `https://${parsed.data.magicDnsName}`;
-    this.tunnelPort = port;
-    this.startedAt = /* @__PURE__ */ new Date();
-    this.joinedTailnet = true;
-    elizaLogger.info(
-      `[CloudTailscaleService] tunnel started: ${this.tunnelUrl}`
-    );
-    return this.tunnelUrl;
-  }
-  async stopTunnel(_options = {}) {
-    if (!this.isActive() && !this.joinedTailnet) {
-      elizaLogger.warn("[CloudTailscaleService] no active tunnel to stop");
-      return;
-    }
-    this.isShuttingDown = true;
-    elizaLogger.info("[CloudTailscaleService] stopping tunnel");
-    if (this.tunnelPort !== null) {
-      await this.cliRunner("tailscale", ["serve", "reset"]);
-      await this.cliRunner("tailscale", ["funnel", "reset"]);
-    }
-    if (this.joinedTailnet) {
-      await this.cliRunner("tailscale", ["logout"]);
-    }
-    this.cleanup();
-    this.isShuttingDown = false;
-    elizaLogger.info("[CloudTailscaleService] tunnel stopped");
-  }
-  getUrl() {
-    return this.tunnelUrl;
-  }
-  isActive() {
-    return this.tunnelUrl !== null && !this.isShuttingDown;
-  }
-  getStatus() {
-    return {
-      active: this.isActive(),
-      url: this.tunnelUrl,
-      port: this.tunnelPort,
-      startedAt: this.startedAt,
-      provider: "tailscale"
-    };
-  }
-  async joinTailnet(payload) {
-    const args = ["up", `--auth-key=${payload.authKey}`];
-    const loginServer = payload.loginServer ?? (payload.tailnet.startsWith("http") ? payload.tailnet : null);
-    if (loginServer) {
-      args.push(`--login-server=${loginServer}`);
-    }
-    if (payload.hostname) {
-      args.push(`--hostname=${payload.hostname}`);
-    }
-    const result = await this.cliRunner("tailscale", args);
-    if (result.code !== 0) {
-      throw new Error(
-        `tailscale up failed (code ${result.code}): ${result.stderr.trim()}`
-      );
-    }
-  }
-  async runServe(port, funnel) {
-    const args = funnel ? ["funnel", String(port)] : ["serve", "--bg", "--https=443", `localhost:${port}`];
-    const result = await this.cliRunner("tailscale", args);
-    if (result.code !== 0) {
-      throw new Error(
-        `tailscale ${args[0]} failed (code ${result.code}): ${result.stderr.trim()}`
-      );
-    }
-  }
-  resolveCloudCredentials(accountId) {
-    const account = accountId ? resolveTailscaleAccount(readTailscaleAccounts(this.runtime), accountId) : null;
-    const apiKey = readNonEmptyString(account?.cloudApiKey) ?? readNonEmptyString(this.runtime.getSetting("ELIZAOS_CLOUD_API_KEY"));
-    if (!apiKey) {
-      throw new Error(
-        "CloudTailscaleService requires ELIZAOS_CLOUD_API_KEY. Set it or use the local backend."
-      );
-    }
-    const baseRaw = readNonEmptyString(account?.cloudBaseUrl) ?? readNonEmptyString(this.runtime.getSetting("ELIZAOS_CLOUD_BASE_URL")) ?? CLOUD_BASE_FALLBACK;
-    return { baseUrl: stripTrailingSlash(baseRaw), apiKey };
-  }
-  cleanup() {
-    this.tunnelUrl = null;
-    this.tunnelPort = null;
-    this.startedAt = null;
-    this.joinedTailnet = false;
-  }
-};
-function readNonEmptyString(value) {
-  if (value === null || value === void 0) return null;
-  const trimmed = String(value).trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function stripTrailingSlash(url) {
-  return url.replace(/\/+$/, "");
-}
-async function safeReadText(response) {
-  const text = await response.text().catch(() => "");
-  return text.slice(0, 500);
-}
-function normalizeFetchResponse(value) {
-  if (!isRecord(value)) {
-    throw new Error("Cloud Tailscale fetch returned a non-object response");
-  }
-  const { ok, status, statusText, json, text } = value;
-  if (typeof ok !== "boolean" || typeof status !== "number" || typeof statusText !== "string" || typeof json !== "function" || typeof text !== "function") {
-    throw new Error(
-      "Cloud Tailscale fetch response is missing required fields"
-    );
-  }
-  return {
-    ok,
-    status,
-    statusText,
-    json: async () => json.call(value),
-    text: async () => String(await text.call(value))
-  };
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/services/LocalTailscaleService.ts
-import { spawn as spawn2 } from "child_process";
-import { elizaLogger as elizaLogger2, Service as Service2 } from "@elizaos/core";
-import { z as z3 } from "zod";
-var tailscaleStatusPeerSchema = z3.object({
-  DNSName: z3.string().optional(),
-  Online: z3.boolean().optional()
-});
-var tailscaleStatusSchema = z3.object({
-  Self: z3.object({
-    DNSName: z3.string().optional()
-  }).optional(),
-  MagicDNSSuffix: z3.string().optional(),
-  Peer: z3.record(z3.string(), tailscaleStatusPeerSchema).optional()
-});
-function runCommand(cmd, args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn2(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
-    const out = [];
-    const err = [];
-    child.stdout?.on("data", (chunk) => out.push(chunk));
-    child.stderr?.on("data", (chunk) => err.push(chunk));
-    child.on("error", reject);
-    child.on(
-      "exit",
-      (code) => resolve({
-        code,
-        stdout: Buffer.concat(out).toString("utf8"),
-        stderr: Buffer.concat(err).toString("utf8")
-      })
-    );
-  });
-}
-function checkTailscaleInstalled() {
-  return new Promise((resolve) => {
-    const proc = spawn2("which", ["tailscale"]);
-    proc.on("exit", (code) => resolve(code === 0));
-    proc.on("error", () => resolve(false));
-  });
-}
-function parseTailscaleStatus(stdout) {
-  let raw;
-  try {
-    raw = JSON.parse(stdout);
-  } catch {
-    return null;
-  }
-  const result = tailscaleStatusSchema.safeParse(raw);
-  return result.success ? result.data : null;
-}
-var LocalTailscaleService = class _LocalTailscaleService extends Service2 {
-  static serviceType = "tunnel";
-  capabilityDescription = "Provides secure tunnel functionality via the locally-installed `tailscale` CLI (serve / funnel).";
-  tunnelUrl = null;
-  tunnelPort = null;
-  startedAt = null;
-  isShuttingDown = false;
-  useFunnel = false;
-  static async start(runtime) {
-    const service = new _LocalTailscaleService(runtime);
-    await service.start();
-    return service;
-  }
-  async start() {
-    elizaLogger2.info("[LocalTailscaleService] starting");
-    const installed = await checkTailscaleInstalled();
-    if (!installed) {
-      throw new Error(
-        "tailscale is not installed. Install from https://tailscale.com/download or run: brew install tailscale"
-      );
-    }
-  }
-  async stop() {
-    await this.stopTunnel();
-  }
-  async startTunnel(port, options = {}) {
-    if (this.isActive()) {
-      elizaLogger2.warn("[LocalTailscaleService] tunnel already running");
-      return this.tunnelUrl ?? void 0;
-    }
-    if (port === void 0 || port === null) {
-      elizaLogger2.warn(
-        "[LocalTailscaleService] startTunnel called without a port \u2014 service active but no tunnel started"
-      );
-      return;
-    }
-    if (port < 1 || port > 65535) {
-      throw new Error("Invalid port number");
-    }
-    const config = await validateTailscaleConfig(
-      this.runtime,
-      options.accountId
-    );
-    this.useFunnel = config.TAILSCALE_FUNNEL;
-    elizaLogger2.info(
-      `[LocalTailscaleService] starting tunnel on port ${port} (funnel=${this.useFunnel})`
-    );
-    if (this.useFunnel) {
-      const result = await runCommand("tailscale", ["funnel", String(port)]);
-      if (result.code !== 0) {
-        throw new Error(
-          `tailscale funnel exited with code ${result.code}: ${result.stderr.trim()}`
-        );
-      }
-    } else {
-      const result = await runCommand("tailscale", [
-        "serve",
-        "--bg",
-        "--https=443",
-        `localhost:${port}`
-      ]);
-      if (result.code !== 0) {
-        throw new Error(
-          `tailscale serve exited with code ${result.code}: ${result.stderr.trim()}`
-        );
-      }
-    }
-    const dnsName = await this.fetchSelfDnsName();
-    if (!dnsName) {
-      throw new Error(
-        "tailscale serve started but no DNSName resolved from `tailscale status --json`"
-      );
-    }
-    this.tunnelUrl = this.useFunnel ? `https://${dnsName}` : `https://${dnsName}`;
-    this.tunnelPort = port;
-    this.startedAt = /* @__PURE__ */ new Date();
-    elizaLogger2.info(
-      `[LocalTailscaleService] tunnel started: ${this.tunnelUrl}`
-    );
-    return this.tunnelUrl;
-  }
-  async stopTunnel(_options = {}) {
-    if (!this.isActive()) {
-      elizaLogger2.warn("[LocalTailscaleService] no active tunnel to stop");
-      return;
-    }
-    this.isShuttingDown = true;
-    elizaLogger2.info("[LocalTailscaleService] stopping tunnel");
-    if (this.useFunnel) {
-      await runCommand("tailscale", ["funnel", "reset"]);
-    } else {
-      await runCommand("tailscale", ["serve", "reset"]);
-    }
-    this.cleanup();
-    this.isShuttingDown = false;
-    elizaLogger2.info("[LocalTailscaleService] tunnel stopped");
-  }
-  getUrl() {
-    return this.tunnelUrl;
-  }
-  isActive() {
-    return this.tunnelUrl !== null && !this.isShuttingDown;
-  }
-  getStatus() {
-    return {
-      active: this.isActive(),
-      url: this.tunnelUrl,
-      port: this.tunnelPort,
-      startedAt: this.startedAt,
-      provider: "tailscale"
-    };
-  }
-  async fetchSelfDnsName() {
-    const result = await runCommand("tailscale", ["status", "--json"]);
-    if (result.code !== 0) {
-      elizaLogger2.error(
-        `[LocalTailscaleService] tailscale status failed: ${result.stderr.trim()}`
-      );
-      return null;
-    }
-    const status = parseTailscaleStatus(result.stdout);
-    if (!status) {
-      elizaLogger2.error(
-        "[LocalTailscaleService] tailscale status returned malformed JSON"
-      );
-      return null;
-    }
-    const raw = status.Self?.DNSName;
-    if (!raw) return null;
-    return raw.replace(/\.$/, "");
-  }
-  cleanup() {
-    this.tunnelUrl = null;
-    this.tunnelPort = null;
-    this.startedAt = null;
-    this.useFunnel = false;
-  }
-};
-
-// src/__tests__/TailscaleTestSuite.ts
-var CANONICAL_TUNNEL_SERVICE_TYPE = "tunnel";
-var TailscaleTestSuite = class {
-  name = "tailscale";
-  tests = [
-    {
-      name: "LocalTailscaleService claims canonical tunnel service-type",
-      fn: (_runtime) => {
-        if (LocalTailscaleService.serviceType !== CANONICAL_TUNNEL_SERVICE_TYPE) {
-          throw new Error(
-            `LocalTailscaleService.serviceType must be "${CANONICAL_TUNNEL_SERVICE_TYPE}"`
-          );
-        }
-      }
-    },
-    {
-      name: "CloudTailscaleService claims canonical tunnel service-type",
-      fn: (_runtime) => {
-        if (CloudTailscaleService.serviceType !== CANONICAL_TUNNEL_SERVICE_TYPE) {
-          throw new Error(
-            `CloudTailscaleService.serviceType must be "${CANONICAL_TUNNEL_SERVICE_TYPE}"`
-          );
-        }
-      }
-    }
-  ];
-};
-
-// src/connector-account-provider.ts
-var TAILSCALE_PROVIDER_ID = "tailscale";
-var DEFAULT_PURPOSES = [
-  "admin",
-  "automation"
-];
-function hasExplicitConfig(account) {
-  return Boolean(
-    account.authKey || account.tags !== void 0 || account.funnel !== void 0 || account.defaultPort !== void 0 || account.backend !== void 0 || account.authKeyExpirySeconds !== void 0 || account.cloudApiKey || account.cloudBaseUrl
-  );
-}
-function authMethodForAccount(account) {
-  if (account.cloudApiKey) return "cloud_api_key";
-  if (account.authKey) return "auth_key";
-  if (account.backend === "local") return "local_cli";
-  return "runtime";
-}
-function toConnectorAccount(account, defaultAccountId) {
-  const now = Date.now();
-  const accountId = normalizeTailscaleAccountId(account.accountId);
-  const configured = hasExplicitConfig(account);
-  return {
-    id: accountId,
-    provider: TAILSCALE_PROVIDER_ID,
-    label: account.label ?? `Tailscale (${accountId})`,
-    role: "OWNER",
-    purpose: DEFAULT_PURPOSES,
-    accessGate: "open",
-    status: configured ? "connected" : "disabled",
-    displayHandle: account.label ?? accountId,
-    createdAt: now,
-    updatedAt: now,
-    metadata: {
-      authMethod: authMethodForAccount(account),
-      source: "legacy",
-      isDefault: accountId === defaultAccountId,
-      backend: account.backend ?? "auto",
-      funnel: account.funnel ?? null,
-      defaultPort: account.defaultPort ?? null,
-      tags: account.tags ?? null,
-      authKeyExpirySeconds: account.authKeyExpirySeconds ?? null,
-      hasAuthKey: Boolean(account.authKey),
-      hasCloudApiKey: Boolean(account.cloudApiKey),
-      cloudBaseUrl: account.cloudBaseUrl ?? null
-    }
-  };
-}
-function normalizePurposes(purpose, fallback) {
-  if (Array.isArray(purpose)) return purpose;
-  if (typeof purpose === "string" && purpose.trim()) return [purpose];
-  return fallback;
-}
-function mergeStoredAccountPatch(account, patch) {
-  return {
-    ...account,
-    ...patch,
-    provider: TAILSCALE_PROVIDER_ID,
-    id: account.id,
-    purpose: normalizePurposes(patch.purpose, account.purpose),
-    externalId: patch.externalId === void 0 ? account.externalId : patch.externalId ?? void 0,
-    displayHandle: patch.displayHandle === void 0 ? account.displayHandle : patch.displayHandle ?? void 0,
-    ownerBindingId: patch.ownerBindingId === void 0 ? account.ownerBindingId : patch.ownerBindingId ?? void 0,
-    ownerIdentityId: patch.ownerIdentityId === void 0 ? account.ownerIdentityId : patch.ownerIdentityId ?? void 0,
-    metadata: patch.metadata ?? account.metadata,
-    createdAt: account.createdAt
-  };
-}
-function createTailscaleConnectorAccountProvider(runtime) {
-  return {
-    provider: TAILSCALE_PROVIDER_ID,
-    label: "Tailscale",
-    listAccounts: async (manager) => {
-      const stored = await manager.getStorage().listAccounts(TAILSCALE_PROVIDER_ID);
-      const storedById = new Set(stored.map((account) => account.id));
-      const defaultAccountId = resolveTailscaleAccountId(runtime);
-      const synthesized = readTailscaleAccounts(runtime).map((account) => toConnectorAccount(account, defaultAccountId)).filter((account) => !storedById.has(account.id));
-      return [...stored, ...synthesized];
-    },
-    createAccount: async (input, _manager) => {
-      return {
-        ...input,
-        provider: TAILSCALE_PROVIDER_ID,
-        role: input.role ?? "OWNER",
-        purpose: input.purpose ?? DEFAULT_PURPOSES,
-        accessGate: input.accessGate ?? "open",
-        status: input.status ?? "pending"
-      };
-    },
-    patchAccount: async (accountId, patch, manager) => {
-      const existing = await manager.getStorage().getAccount(TAILSCALE_PROVIDER_ID, accountId);
-      if (existing) {
-        return mergeStoredAccountPatch(existing, patch);
-      }
-      return { ...patch, provider: TAILSCALE_PROVIDER_ID };
-    },
-    deleteAccount: async (_accountId, _manager) => {
-    }
-  };
-}
-
-// src/types.ts
-import {
-  getTunnelService
-} from "@elizaos/plugin-tunnel";
-
-// src/providers/tailscale-status.ts
-function formatUptime(startedAt) {
-  const ms = Date.now() - startedAt.getTime();
-  const minutes = Math.floor(ms / 6e4);
-  const hours = Math.floor(minutes / 60);
-  if (hours > 0) {
-    return `${hours} hour${hours === 1 ? "" : "s"}, ${minutes % 60} minute${minutes % 60 === 1 ? "" : "s"}`;
-  }
-  return `${minutes} minute${minutes === 1 ? "" : "s"}`;
-}
-var tailscaleStatusProvider = {
-  name: "tailscaleStatus",
-  description: "Current Tailscale tunnel status: active flag, public URL, local port, uptime, backend provider.",
-  descriptionCompressed: "Tailscale tunnel status: active, url, port, uptime.",
-  dynamic: true,
-  contexts: ["settings", "connectors"],
-  contextGate: { anyOf: ["settings", "connectors"] },
-  cacheStable: false,
-  cacheScope: "turn",
-  get: async (runtime, _message, _state) => {
-    const tunnelService = getTunnelService(runtime);
-    if (!tunnelService) {
-      return { text: "" };
-    }
-    const status = tunnelService.getStatus();
-    const uptime = status.startedAt ? formatUptime(status.startedAt) : null;
-    const text = JSON.stringify({
-      tailscale: {
-        active: status.active,
-        url: status.url,
-        port: status.port,
-        uptime,
-        provider: status.provider
-      }
-    });
-    return {
-      text,
-      values: {
-        active: status.active,
-        url: status.url ?? "",
-        port: status.port ?? 0,
-        provider: status.provider
-      },
-      data: { status, uptime }
-    };
-  }
-};
-
-// src/services/TunnelBackendSelector.ts
-import { isCloudConnected } from "@elizaos/cloud-routing";
-import { elizaLogger as elizaLogger3 } from "@elizaos/core";
-var ALLOWED_MODES = /* @__PURE__ */ new Set([
-  "local",
-  "cloud",
-  "auto"
-]);
-function readBackendMode(runtime) {
-  const account = resolveTailscaleAccount(
-    readTailscaleAccounts(runtime),
-    resolveTailscaleAccountId(runtime)
-  );
-  const raw = account?.backend ?? runtime.getSetting("TAILSCALE_BACKEND");
-  if (raw === null || raw === void 0) return "auto";
-  const normalized = String(raw).trim().toLowerCase();
-  if (ALLOWED_MODES.has(normalized)) {
-    return normalized;
-  }
-  elizaLogger3.warn(
-    `[TunnelBackendSelector] invalid TAILSCALE_BACKEND="${raw}" \u2014 falling back to "auto"`
-  );
-  return "auto";
-}
-function selectTunnelBackend(runtime) {
-  const mode = readBackendMode(runtime);
-  switch (mode) {
-    case "local":
-      return {
-        backend: LocalTailscaleService,
-        mode,
-        reason: "TAILSCALE_BACKEND=local"
-      };
-    case "cloud":
-      return {
-        backend: CloudTailscaleService,
-        mode,
-        reason: "TAILSCALE_BACKEND=cloud"
-      };
-    case "auto": {
-      if (isCloudConnected(runtime)) {
-        return {
-          backend: CloudTailscaleService,
-          mode,
-          reason: "auto: cloud connected"
-        };
-      }
-      return {
-        backend: LocalTailscaleService,
-        mode,
-        reason: "auto: cloud not connected"
-      };
-    }
-  }
-}
-
-// src/index.ts
-var tailscalePlugin = {
-  name: "tailscale",
-  description: "Tunnel plugin with local Tailscale serve/funnel and cloud-proxy backends.",
-  actions: [],
-  providers: [tailscaleStatusProvider],
-  tests: [new TailscaleTestSuite()],
-  init: async (_config, runtime) => {
-    try {
-      const manager = getConnectorAccountManager(runtime);
-      manager.registerProvider(
-        createTailscaleConnectorAccountProvider(runtime)
-      );
-    } catch (err) {
-      elizaLogger4.warn(
-        `[plugin-tailscale] failed to register ConnectorAccountManager provider: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    if (!tunnelSlotIsFree(runtime)) {
-      elizaLogger4.info(
-        "[plugin-tailscale] another tunnel service already registered \u2014 skipping Tailscale backend"
-      );
-      return;
-    }
-    const decision = selectTunnelBackend(runtime);
-    elizaLogger4.info(
-      `[plugin-tailscale] tunnel backend: ${decision.backend.name} (${decision.reason})`
-    );
-    await runtime.registerService(decision.backend);
-  }
-};
-var index_default = tailscalePlugin;
-export {
-  CloudTailscaleService,
-  DEFAULT_TAILSCALE_ACCOUNT_ID,
-  LocalTailscaleService,
-  createTailscaleConnectorAccountProvider,
-  index_default as default,
-  normalizeTailscaleAccountId,
-  readBackendMode,
-  readTailscaleAccounts,
-  resolveTailscaleAccount,
-  resolveTailscaleAccountId,
-  selectTunnelBackend,
-  tailscalePlugin
-};
-//# sourceMappingURL=index.js.map