Cf Tunnel

#!/usr/bin/env bun
// 统一入口：Cloudflare 临时暴露 + 管理面板

import { execSync } from "child_process";
import * as fs from "fs";
import * as os from "os";
import * as path from "path";
import {
  findAvailablePort,
  isPortInUse,
  tmuxSessionExists,
  killTmuxSession,
  execSilent,
  printStatus,
} from "./lib/utils.ts";

const SCRIPT_DIR = import.meta.dir;
const SHARE_SCRIPT = path.join(SCRIPT_DIR, "share.ts");
const PANEL_SCRIPT = path.join(SCRIPT_DIR, "panel.ts");

const SHARE_DIR = path.join(os.homedir(), ".cf-tunnel");
const SHARE_FILE = path.join(SHARE_DIR, "share.json");
const SHARE_LOG = path.join(SHARE_DIR, "share-tunnel.log");
const PANEL_STATE = path.join(SHARE_DIR, "panel.json");

const PANEL_SESSION = "cf-share-panel";
const DEFAULT_PANEL_PORT = 8788;
const DEFAULT_PANEL_HOST = "127.0.0.1";

type PanelState = {
  host: string;
  port: number;
  startedAt: string;
  session: string;
};

type Parsed = {
  cmd: string;
  sub?: string;
  flags: Record<string, string | boolean>;
  rest: string[];
};

function usage() {
  console.log(`
CF Tunnel 统一命令（Bun CLI）

用法：
  bun ~/.pi/agent/skills/cf-tunnel/scripts/cf.ts <command> [options]

主命令：
  start [share options]     启动临时暴露（等同 share start）
  stop [--all|--share|--panel]
                            停止服务（默认 --all）
  status                    查看 share + panel 综合状态

子命令：
  share start [--port N|--dir PATH|--file PATH] [--route /path]
  share status
  share stop

  panel start [--port N|--host 127.0.0.1]
  panel status
  panel stop

示例：
  bun ~/.pi/agent/skills/cf-tunnel/scripts/cf.ts start --dir ./demos/html
  bun ~/.pi/agent/skills/cf-tunnel/scripts/cf.ts panel start --port 8788
  bun ~/.pi/agent/skills/cf-tunnel/scripts/cf.ts status
`);
}

function ensureShareDir() {
  if (!fs.existsSync(SHARE_DIR)) fs.mkdirSync(SHARE_DIR, { recursive: true });
}

function parseArgs(argv: string[]): Parsed {
  const [cmd = "status", maybeSub, ...restRaw] = argv;
  const hasSub = cmd === "share" || cmd === "panel";
  const sub = hasSub ? maybeSub || "status" : undefined;
  const rest = hasSub ? restRaw : [maybeSub, ...restRaw].filter(Boolean) as string[];

  const flags: Record<string, string | boolean> = {};
  const positional: string[] = [];

  for (let i = 0; i < rest.length; i++) {
    const arg = rest[i];
    if (arg.startsWith("--")) {
      const key = arg.slice(2);
      const next = rest[i + 1];
      if (!next || next.startsWith("--")) {
        flags[key] = true;
      } else {
        flags[key] = next;
        i++;
      }
    } else {
      positional.push(arg);
    }
  }

  return { cmd, sub, flags, rest: positional };
}

function loadPanelState(): PanelState | null {
  try {
    if (!fs.existsSync(PANEL_STATE)) return null;
    return JSON.parse(fs.readFileSync(PANEL_STATE, "utf-8"));
  } catch {
    return null;
  }
}

function savePanelState(state: PanelState) {
  ensureShareDir();
  fs.writeFileSync(PANEL_STATE, JSON.stringify(state, null, 2), "utf-8");
}

function removePanelState() {
  try {
    if (fs.existsSync(PANEL_STATE)) fs.unlinkSync(PANEL_STATE);
  } catch {
    // ignore
  }
}

function getTryUrlFromLog(): string | null {
  try {
    if (!fs.existsSync(SHARE_LOG)) return null;
    const content = fs.readFileSync(SHARE_LOG, "utf-8");
    const m = content.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
    return m?.[0] ?? null;
  } catch {
    return null;
  }
}

function loadShareConfig(): any | null {
  try {
    if (!fs.existsSync(SHARE_FILE)) return null;
    return JSON.parse(fs.readFileSync(SHARE_FILE, "utf-8"));
  } catch {
    return null;
  }
}

function runShare(args: string[]): number {
  try {
    execSync(`bun "${SHARE_SCRIPT}" ${args.map((a) => `"${a.replaceAll('"', '\\"')}"`).join(" ")}`, {
      stdio: "inherit",
    });
    return 0;
  } catch {
    return 1;
  }
}

function startPanel(flags: Record<string, string | boolean>) {
  if (tmuxSessionExists(PANEL_SESSION)) {
    const current = loadPanelState();
    printStatus("running", `Panel 已运行: http://${current?.host ?? DEFAULT_PANEL_HOST}:${current?.port ?? DEFAULT_PANEL_PORT}`);
    return;
  }

  const host = String(flags.host || DEFAULT_PANEL_HOST);
  const requestedPort = Number(flags.port || DEFAULT_PANEL_PORT);
  let port = Number.isFinite(requestedPort) ? requestedPort : DEFAULT_PANEL_PORT;

  if (isPortInUse(port)) {
    const nextPort = findAvailablePort(port + 1, 50);
    if (!nextPort) {
      console.error(`❌ 面板端口 ${port} 被占用，且未找到可用端口`);
      process.exit(1);
    }
    console.log(`⚠️ 端口 ${port} 被占用，自动改用 ${nextPort}`);
    port = nextPort;
  }

  const cmd = `bun "${PANEL_SCRIPT}" --port ${port} --host ${host}`;
  execSync(`tmux new-session -d -s ${PANEL_SESSION} "${cmd}"`, { stdio: "inherit" });

  savePanelState({ host, port, startedAt: new Date().toISOString(), session: PANEL_SESSION });
  printStatus("running", `Panel 已启动: http://${host}:${port}`);
}

function stopPanel() {
  if (tmuxSessionExists(PANEL_SESSION)) {
    killTmuxSession(PANEL_SESSION);
    printStatus("stopped", "Panel 已停止");
  } else {
    printStatus("stopped", "Panel 未运行");
  }
  removePanelState();
}

function statusPanel() {
  const running = tmuxSessionExists(PANEL_SESSION);
  const state = loadPanelState();
  printStatus(running ? "running" : "stopped", "Panel (cf-share-panel)");
  if (running) {
    const host = state?.host ?? DEFAULT_PANEL_HOST;
    const port = state?.port ?? DEFAULT_PANEL_PORT;
    console.log(`   URL: http://${host}:${port}`);
  }
}

function statusAll() {
  console.log("\n📊 CF Tunnel 综合状态\n");

  const shareCfg = loadShareConfig();
  const shareUrl = getTryUrlFromLog();

  const webRunning = tmuxSessionExists("cf-share-web");
  const tunnelRunning = tmuxSessionExists("cf-share-tunnel");
  printStatus(webRunning ? "running" : "stopped", "Share Web (cf-share-web)");
  printStatus(tunnelRunning ? "running" : "stopped", "Share Tunnel (cf-share-tunnel)");

  if (shareCfg) {
    console.log(`   模式: ${shareCfg.mode}`);
    console.log(`   端口: ${shareCfg.localPort}`);
  }

  console.log(`   公网: ${shareUrl ?? "(等待中或未启动)"}`);

  if (shareCfg?.fileRoute && shareUrl) {
    const route = String(shareCfg.fileRoute).startsWith("/")
      ? shareCfg.fileRoute
      : `/${shareCfg.fileRoute}`;
    console.log(`   文件: ${shareUrl}${route}`);
  }

  console.log("");
  statusPanel();
  console.log("");
}

function stopAll(flags: Record<string, string | boolean>) {
  const stopShareOnly = Boolean(flags.share);
  const stopPanelOnly = Boolean(flags.panel);
  const stopAll = Boolean(flags.all) || (!stopShareOnly && !stopPanelOnly);

  if (stopAll || stopShareOnly) {
    runShare(["stop"]);
  }
  if (stopAll || stopPanelOnly) {
    stopPanel();
  }
}

(function main() {
  const parsed = parseArgs(process.argv.slice(2));

  if (["help", "--help", "-h"].includes(parsed.cmd)) {
    usage();
    return;
  }

  if (parsed.cmd === "start") {
    process.exit(runShare(["start", ...process.argv.slice(3)]));
  }

  if (parsed.cmd === "stop") {
    stopAll(parsed.flags);
    return;
  }

  if (parsed.cmd === "status") {
    statusAll();
    return;
  }

  if (parsed.cmd === "share") {
    const sub = parsed.sub || "status";
    if (!["start", "stop", "status"].includes(sub)) {
      usage();
      process.exit(1);
    }
    process.exit(runShare([sub, ...process.argv.slice(4)]));
  }

  if (parsed.cmd === "panel") {
    const sub = parsed.sub || "status";
    if (sub === "start") {
      startPanel(parsed.flags);
      return;
    }
    if (sub === "stop") {
      stopPanel();
      return;
    }
    if (sub === "status") {
      statusPanel();
      return;
    }
    usage();
    process.exit(1);
  }

  usage();
  process.exit(1);
})();

#!/usr/bin/env bun
// 初始化 Cloudflare Tunnel 配置

import {
  CONFIG_DIR,
  CONFIG_FILE,
  DEFAULT_CONFIG,
  saveConfig,
  exec,
  execSilent,
  ensureDir,
  prompt,
} from "./lib/utils.ts";

console.log("🚀 Cloudflare Tunnel 初始化\n");

// 检查 cloudflared
console.log("📋 检查 cloudflared...");
const version = execSilent("cloudflared --version");
if (!version) {
  console.error("❌ cloudflared 未安装");
  console.log("💡 安装命令:");
  console.log("   wget -q https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb");
  console.log("   sudo dpkg -i cloudflared-linux-amd64.deb");
  process.exit(1);
}
console.log(`✅ cloudflared ${version}\n`);

// 检查 tmux
console.log("📋 检查 tmux...");
const tmuxVersion = execSilent("tmux -V");
if (!tmuxVersion) {
  console.error("❌ tmux 未安装");
  console.log("💡 安装: sudo apt install tmux");
  process.exit(1);
}
console.log(`✅ ${tmuxVersion}\n`);

// 登录 Cloudflare
console.log("🔐 登录 Cloudflare...");
console.log("   将打开浏览器进行授权\n");
const loginResult = execSilent("cloudflared tunnel login");
if (!loginResult && !execSilent("ls ~/.cloudflared/*.json 2>/dev/null")) {
  console.error("❌ 登录失败");
  process.exit(1);
}
console.log("✅ 登录成功\n");

// 配置参数
const tunnelName = await prompt(`隧道名称 [${DEFAULT_CONFIG.tunnelName}]: `) || DEFAULT_CONFIG.tunnelName;
const hostname = await prompt("域名 (如 mysite.example.com): ");
if (!hostname) {
  console.error("❌ 域名不能为空");
  process.exit(1);
}

const portStr = await prompt("本地端口 (留空自动分配): ");
const localPort = parseInt(portStr, 10) || 0; // 0 表示自动分配

const webDir = await prompt(`网站目录 [${DEFAULT_CONFIG.webDir}]: `) || DEFAULT_CONFIG.webDir;

// 创建目录
ensureDir(webDir);
ensureDir(CONFIG_DIR);

// 创建隧道
console.log(`\n🔧 创建隧道 "${tunnelName}"...`);
const createOutput = exec(`cloudflared tunnel create ${tunnelName}`, true);

// 提取 tunnel ID
let tunnelId = "";
const match = createOutput.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
if (match) {
  tunnelId = match[1];
} else {
  // 尝试从 list 获取
  const listOutput = execSilent("cloudflared tunnel list");
  const lines = listOutput.split("\n");
  for (const line of lines) {
    if (line.includes(tunnelName)) {
      const parts = line.trim().split(/\s+/);
      if (parts[0] && parts[0].includes("-")) {
        tunnelId = parts[0];
        break;
      }
    }
  }
}

if (!tunnelId) {
  console.error("❌ 无法获取隧道 ID");
  process.exit(1);
}
console.log(`✅ 隧道 ID: ${tunnelId}\n`);

// 创建配置文件（端口设为0表示自动分配）
const config = {
  ...DEFAULT_CONFIG,
  tunnelId,
  tunnelName,
  hostname,
  localPort: localPort || 0,
  webDir,
};

// 创建 cloudflared config.yml
const cloudflaredDir = `${process.env.HOME}/.cloudflared`;
ensureDir(cloudflaredDir);

const configYml = `tunnel: ${tunnelId}
credentials-file: ${cloudflaredDir}/${tunnelId}.json

ingress:
  - hostname: ${hostname}
    service: http://localhost:${localPort}
  - service: http_status:404
`;

import * as fs from "fs";
fs.writeFileSync(`${cloudflaredDir}/config-${tunnelName}.yml`, configYml);

// 添加 DNS 记录
console.log(`🌐 添加 DNS 记录: ${hostname}...`);
exec(`cloudflared tunnel route dns ${tunnelName} ${hostname}`);
console.log("✅ DNS 记录已添加\n");

// 保存配置
saveConfig(config);

console.log("✅ 初始化完成！\n");
console.log("配置信息:");
console.log(`  隧道: ${tunnelName} (${tunnelId})`);
console.log(`  域名: https://${hostname}`);
console.log(`  本地端口: ${localPort || "自动分配 (10000-65000)"}`);
console.log(`  网站目录: ${webDir}\n`);
console.log("启动命令:");
console.log(`  bun ~/.pi/agent/skills/cf-tunnel/scripts/start.ts\n`);

/**
 * 端口暴露管理器 - 内存 + 临时文件存储
 * 管理通过 CF Tunnel 暴露的本地端口
 */

import { execSync } from "child_process";
import * as fs from "fs";
import * as path from "path";
import * as os from "os";
import { isPortInUse, tmuxSessionExists, killTmuxSession, execSilent, findAvailablePort } from "./utils.ts";

const SHARE_DIR = path.join(os.homedir(), ".cf-tunnel");
const PORT_STATE_FILE = path.join(SHARE_DIR, "ports.json");
const TUNNEL_LOG_DIR = path.join(SHARE_DIR, "logs");

export type PortEntry = {
  id: string;           // 唯一标识
  name: string;         // 自定义名称
  localPort: number;    // 本地端口
  publicUrl?: string;   // 公网 URL
  pid?: number;         // tunnel 进程 ID
  sessionName: string;  // tmux session 名
  createdAt: string;
  status: "running" | "stopped" | "error";
  logFile: string;
  metadata?: Record<string, any>;
};

// 内存存储
let _portRegistry = new Map<string, PortEntry>();
let _initialized = false;

function ensureDirs(): void {
  if (!fs.existsSync(SHARE_DIR)) fs.mkdirSync(SHARE_DIR, { recursive: true });
  if (!fs.existsSync(TUNNEL_LOG_DIR)) fs.mkdirSync(TUNNEL_LOG_DIR, { recursive: true });
}

function generateId(): string {
  return `port-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
}

function generateSessionName(port: number): string {
  return `cf-port-${port}`;
}

/**
 * 从临时文件加载状态
 */
export function loadPortState(): void {
  if (_initialized) return;
  ensureDirs();
  
  try {
    if (fs.existsSync(PORT_STATE_FILE)) {
      const data = JSON.parse(fs.readFileSync(PORT_STATE_FILE, "utf-8"));
      if (Array.isArray(data)) {
        for (const entry of data) {
          // 验证 session 是否还在运行
          const isRunning = tmuxSessionExists(entry.sessionName);
          entry.status = isRunning ? "running" : "stopped";
          
          // 如果运行中，尝试获取 URL
          if (isRunning && fs.existsSync(entry.logFile)) {
            entry.publicUrl = extractUrlFromLog(entry.logFile);
          }
          
          _portRegistry.set(entry.id, entry);
        }
      }
    }
  } catch (e) {
    console.error("加载端口状态失败:", e);
  }
  _initialized = true;
}

/**
 * 保存到临时文件
 */
export function savePortState(): void {
  ensureDirs();
  const data = Array.from(_portRegistry.values());
  fs.writeFileSync(PORT_STATE_FILE, JSON.stringify(data, null, 2), "utf-8");
}

/**
 * 从日志提取 URL
 */
function extractUrlFromLog(logFile: string): string | undefined {
  try {
    if (!fs.existsSync(logFile)) return undefined;
    const content = fs.readFileSync(logFile, "utf-8");
    const m = content.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
    return m?.[0];
  } catch {
    return undefined;
  }
}

/**
 * 列出所有端口暴露
 */
export function listPorts(): PortEntry[] {
  loadPortState();
  // 刷新状态
  for (const entry of _portRegistry.values()) {
    entry.status = tmuxSessionExists(entry.sessionName) ? "running" : "stopped";
    if (entry.status === "running" && !entry.publicUrl) {
      entry.publicUrl = extractUrlFromLog(entry.logFile);
    }
  }
  return Array.from(_portRegistry.values()).sort((a, b) => 
    new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
  );
}

/**
 * 获取单个端口信息
 */
export function getPort(id: string): PortEntry | undefined {
  loadPortState();
  const entry = _portRegistry.get(id);
  if (entry) {
    entry.status = tmuxSessionExists(entry.sessionName) ? "running" : "stopped";
  }
  return entry;
}

/**
 * 通过本地端口查找
 */
export function findByLocalPort(port: number): PortEntry | undefined {
  loadPortState();
  for (const entry of _portRegistry.values()) {
    if (entry.localPort === port) {
      entry.status = tmuxSessionExists(entry.sessionName) ? "running" : "stopped";
      return entry;
    }
  }
  return undefined;
}

/**
 * 添加并暴露端口
 */
export async function addPort(
  port: number, 
  name?: string,
  metadata?: Record<string, any>
): Promise<PortEntry> {
  loadPortState();
  
  // 检查 cloudflared
  if (!execSilent("which cloudflared")) {
    throw new Error("未找到 cloudflared，请先安装");
  }
  
  // 检查端口是否监听
  if (!isPortInUse(port)) {
    throw new Error(`端口 ${port} 未监听，请先启动本地服务`);
  }
  
  // 检查是否已存在
  const existing = findByLocalPort(port);
  if (existing && existing.status === "running") {
    throw new Error(`端口 ${port} 已在暴露中 (ID: ${existing.id})`);
  }
  
  const id = generateId();
  const sessionName = generateSessionName(port);
  const logFile = path.join(TUNNEL_LOG_DIR, `${sessionName}.log`);
  
  // 清理旧 session
  if (tmuxSessionExists(sessionName)) {
    killTmuxSession(sessionName);
  }
  
  // 清理旧日志
  if (fs.existsSync(logFile)) {
    fs.unlinkSync(logFile);
  }
  
  // 启动 tunnel
  const cmd = `cloudflared tunnel --no-autoupdate --url http://localhost:${port} > "${logFile}" 2>&1`;
  execSync(`tmux new-session -d -s ${sessionName} "${cmd}"`, { stdio: "pipe" });
  
  const entry: PortEntry = {
    id,
    name: name || `Port ${port}`,
    localPort: port,
    sessionName,
    createdAt: new Date().toISOString(),
    status: "running",
    logFile,
    metadata,
  };
  
  _portRegistry.set(id, entry);
  savePortState();
  
  // 等待 URL
  await waitForUrl(entry, 15000);
  
  return entry;
}

/**
 * 等待 URL 生成
 */
async function waitForUrl(entry: PortEntry, timeoutMs: number): Promise<void> {
  const started = Date.now();
  while (Date.now() - started < timeoutMs) {
    const url = extractUrlFromLog(entry.logFile);
    if (url) {
      entry.publicUrl = url;
      savePortState();
      return;
    }
    await new Promise((r) => setTimeout(r, 500));
  }
}

/**
 * 停止端口暴露
 */
export function removePort(id: string): boolean {
  loadPortState();
  const entry = _portRegistry.get(id);
  if (!entry) return false;
  
  if (tmuxSessionExists(entry.sessionName)) {
    killTmuxSession(entry.sessionName);
  }
  
  entry.status = "stopped";
  _portRegistry.delete(id);
  savePortState();
  
  return true;
}

/**
 * 停止指定本地端口的暴露
 */
export function removeByLocalPort(port: number): boolean {
  const entry = findByLocalPort(port);
  if (entry) {
    return removePort(entry.id);
  }
  return false;
}

/**
 * 停止所有端口暴露
 */
export function removeAllPorts(): number {
  loadPortState();
  let count = 0;
  for (const entry of _portRegistry.values()) {
    if (tmuxSessionExists(entry.sessionName)) {
      killTmuxSession(entry.sessionName);
      count++;
    }
  }
  _portRegistry.clear();
  savePortState();
  return count;
}

/**
 * 刷新所有端口状态
 */
export function refreshPorts(): PortEntry[] {
  loadPortState();
  const entries = Array.from(_portRegistry.values());
  
  for (const entry of entries) {
    const wasRunning = entry.status === "running";
    const isRunning = tmuxSessionExists(entry.sessionName);
    
    if (wasRunning && !isRunning) {
      // Tunnel 意外停止
      entry.status = "stopped";
    } else if (isRunning) {
      entry.status = "running";
      entry.publicUrl = extractUrlFromLog(entry.logFile);
    }
  }
  
  savePortState();
  return entries;
}

/**
 * 获取状态摘要
 */
export function getStatus(): { total: number; running: number; stopped: number } {
  const entries = listPorts();
  return {
    total: entries.length,
    running: entries.filter((e) => e.status === "running").length,
    stopped: entries.filter((e) => e.status === "stopped").length,
  };
}

// 初始化
loadPortState();

// 通用工具函数
import { execSync, spawn } from "child_process";
import * as fs from "fs";
import * as path from "path";
import * as os from "os";

export const CONFIG_DIR = path.join(os.homedir(), ".cf-tunnel");
export const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");

export interface Config {
  tunnelId: string;
  tunnelName: string;
  hostname: string;
  localPort: number;
  webDir: string;
  tmux: {
    webSession: string;
    tunnelSession: string;
  };
}

export const DEFAULT_CONFIG: Config = {
  tunnelId: "",
  tunnelName: "my-website",
  hostname: "",
  localPort: 8080,
  webDir: path.join(os.homedir(), "my-website"),
  tmux: {
    webSession: "cf-web",
    tunnelSession: "cf-tunnel",
  },
};

export function loadConfig(): Config | null {
  try {
    if (!fs.existsSync(CONFIG_FILE)) return null;
    const content = fs.readFileSync(CONFIG_FILE, "utf-8");
    return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
  } catch {
    return null;
  }
}

export function saveConfig(config: Config): void {
  if (!fs.existsSync(CONFIG_DIR)) {
    fs.mkdirSync(CONFIG_DIR, { recursive: true });
  }
  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
}

export function exec(cmd: string, silent = false): string {
  try {
    return execSync(cmd, { encoding: "utf-8", stdio: silent ? "pipe" : "inherit" });
  } catch (e: any) {
    if (silent) return "";
    throw e;
  }
}

export function execSilent(cmd: string): string {
  return exec(cmd, true).trim();
}

export function tmuxSessionExists(name: string): boolean {
  try {
    execSync(`tmux has-session -t ${name}`, { stdio: "ignore" });
    return true;
  } catch {
    return false;
  }
}

export function killTmuxSession(name: string): void {
  try {
    execSync(`tmux kill-session -t ${name} 2>/dev/null`, { stdio: "ignore" });
  } catch {
    // ignore
  }
}

export function getTmuxSessionPid(name: string): number | null {
  try {
    const pid = execSync(`tmux list-panes -t ${name} -F "#{pane_pid}" 2>/dev/null`, {
      encoding: "utf-8",
    }).trim();
    return pid ? parseInt(pid, 10) : null;
  } catch {
    return null;
  }
}

export function isPortInUse(port: number): boolean {
  try {
    execSync(`lsof -Pi :${port} -sTCP:LISTEN -t >/dev/null 2>&1`);
    return true;
  } catch {
    return false;
  }
}

export function getPortPid(port: number): number | null {
  try {
    const pid = execSync(`lsof -Pi :${port} -sTCP:LISTEN -t 2>/dev/null`, {
      encoding: "utf-8",
    }).trim().split("\n")[0];
    return pid ? parseInt(pid, 10) : null;
  } catch {
    return null;
  }
}

export function getProcessInfo(pid: number): { command: string; user: string } | null {
  try {
    const cmd = execSync(`ps -p ${pid} -o comm= 2>/dev/null`, { encoding: "utf-8" }).trim();
    const user = execSync(`ps -p ${pid} -o user= 2>/dev/null`, { encoding: "utf-8" }).trim();
    return { command: cmd, user };
  } catch {
    return null;
  }
}

export function killProcess(pid: number, signal: "SIGTERM" | "SIGKILL" = "SIGTERM"): boolean {
  try {
    process.kill(pid, signal);
    return true;
  } catch {
    return false;
  }
}

// 获取一个随机高端口（10000-65000），避免常见端口冲突
export function getRandomPort(): number {
  return Math.floor(Math.random() * (65000 - 10000) + 10000);
}

// 查找可用端口，优先使用随机高端口
export function findAvailablePort(startPort?: number, maxTry = 20): number | null {
  // 如果没有指定起始端口，使用随机高端口
  let port = startPort ?? getRandomPort();
  
  for (let i = 0; i < maxTry; i++) {
    if (!isPortInUse(port)) return port;
    // 端口被占用，尝试下一个随机端口
    port = getRandomPort();
  }
  return null;
}

// 获取并自动分配一个可用端口
export function assignAvailablePort(): number {
  const port = findAvailablePort();
  if (!port) {
    throw new Error("无法找到可用端口");
  }
  return port;
}

export function printStatus(status: "running" | "stopped" | "error", message: string): void {
  const icons = { running: "🟢", stopped: "🔴", error: "🟡" };
  console.log(`${icons[status]} ${message}`);
}

export function ensureDir(dir: string): void {
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }
}

export function createSampleHtml(dir: string): void {
  const html = `<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Cloudflare Tunnel Site</title>
    <style>
        body { 
            font-family: system-ui, -apple-system, sans-serif; 
            max-width: 800px; 
            margin: 50px auto; 
            padding: 20px;
            line-height: 1.6;
        }
        h1 { color: #f48120; }
        .meta { color: #666; font-size: 0.9em; }
    </style>
</head>
<body>
    <h1>🚀 网站已上线</h1>
    <p>通过 Cloudflare Tunnel 成功暴露到公网！</p>
    <p class="meta">启动时间: <span id="time"></span></p>
    <script>document.getElementById('time').textContent = new Date().toLocaleString()</script>
</body>
</html>`;
  fs.writeFileSync(path.join(dir, "index.html"), html);
}

export async function prompt(question: string): Promise<string> {
  process.stdout.write(question);
  return new Promise((resolve) => {
    const stdin = process.stdin;
    stdin.resume();
    stdin.setEncoding("utf-8");
    stdin.once("data", (data) => {
      stdin.pause();
      resolve(data.toString().trim());
    });
  });
}

export async function confirm(question: string): Promise<boolean> {
  const answer = await prompt(`${question} [y/N]: `);
  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
}

#!/usr/bin/env bun
// 查看日志

import { loadConfig, tmuxSessionExists } from "./lib/utils.ts";

const args = process.argv.slice(2);
const showWeb = args.includes("--web");
const showTunnel = args.includes("--tunnel");
const showAll = !showWeb && !showTunnel;

const config = loadConfig();
if (!config) {
  console.log("⚠️ 未找到配置\n");
  process.exit(1);
}

console.log("📜 日志查看\n");
console.log("提示: 按 Ctrl+B 然后 D 退出日志视图\n");

if ((showAll || showWeb) && tmuxSessionExists(config.tmux.webSession)) {
  console.log("正在打开 Web 服务器日志...\n");
  try {
    const { execSync } = await import("child_process");
    execSync(`tmux attach -t ${config.tmux.webSession}`, { stdio: "inherit" });
  } catch {
    // 用户退出
  }
}

if ((showAll || showTunnel) && tmuxSessionExists(config.tmux.tunnelSession)) {
  console.log("正在打开 Tunnel 日志...\n");
  try {
    const { execSync } = await import("child_process");
    execSync(`tmux attach -t ${config.tmux.tunnelSession}`, { stdio: "inherit" });
  } catch {
    // 用户退出
  }
}

#!/usr/bin/env bun
// Cloudflare 通用临时暴露管理面板（本地）

import { spawnSync } from "child_process";
import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
import { join } from "path";
import { homedir } from "os";
import { tmuxSessionExists, isPortInUse, findAvailablePort } from "./lib/utils.ts";

const SHARE_DIR = join(homedir(), ".cf-tunnel");
const SHARE_FILE = join(SHARE_DIR, "share.json");
const SHARE_LOG = join(SHARE_DIR, "share-tunnel.log");
const HISTORY_FILE = join(SHARE_DIR, "share-history.json");
const WEB_SESSION = "cf-share-web";
const TUNNEL_SESSION = "cf-share-tunnel";
const SHARE_SCRIPT = join(import.meta.dir, "share.ts");
const PANEL_HTML = join(import.meta.dir, "../web/panel.html");

function ensureShareDir() {
  if (!existsSync(SHARE_DIR)) mkdirSync(SHARE_DIR, { recursive: true });
}

function parsePanelArgs() {
  const args = process.argv.slice(2);

  // 兼容旧用法：panel.ts 8790 0.0.0.0
  let legacyPort: string | undefined;
  let legacyHost: string | undefined;
  if (args[0] && !args[0].startsWith("--")) legacyPort = args[0];
  if (args[1] && !args[1].startsWith("--")) legacyHost = args[1];

  const flags: Record<string, string> = {};
  for (let i = 0; i < args.length; i++) {
    const a = args[i];
    const b = args[i + 1];
    if (!a.startsWith("--")) continue;
    if (b && !b.startsWith("--")) {
      flags[a.slice(2)] = b;
      i++;
    } else {
      flags[a.slice(2)] = "true";
    }
  }

  const host = flags.host || legacyHost || "127.0.0.1";
  const askedPort = Number(flags.port || legacyPort || 8788);
  let port = Number.isFinite(askedPort) ? askedPort : 8788;

  if (isPortInUse(port)) {
    const fallback = findAvailablePort(port + 1, 50);
    if (!fallback) {
      console.error(`❌ 面板端口 ${port} 被占用，且未找到可用端口`);
      process.exit(1);
    }
    console.log(`⚠️ 面板端口 ${port} 被占用，自动改用 ${fallback}`);
    port = fallback;
  }

  return { host, port };
}

function getTryUrlFromLog(): string | null {
  try {
    if (!existsSync(SHARE_LOG)) return null;
    const content = readFileSync(SHARE_LOG, "utf-8");
    const m = content.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
    return m?.[0] ?? null;
  } catch {
    return null;
  }
}

function getLastLogTail(lines = 40): string {
  try {
    if (!existsSync(SHARE_LOG)) return "";
    const content = readFileSync(SHARE_LOG, "utf-8").split("\n");
    return content.slice(-lines).join("\n").trim();
  } catch {
    return "";
  }
}

function loadShareConfig(): any | null {
  try {
    if (!existsSync(SHARE_FILE)) return null;
    return JSON.parse(readFileSync(SHARE_FILE, "utf-8"));
  } catch {
    return null;
  }
}

type HistoryItem = {
  mode: string;
  localPort: number;
  webDir?: string;
  filePath?: string;
  fileRoute?: string;
  tunnelUrl: string;
  fileUrl?: string;
  startedAt?: string;
  stoppedAt?: string;
};

function loadHistory(): HistoryItem[] {
  try {
    if (!existsSync(HISTORY_FILE)) return [];
    return JSON.parse(readFileSync(HISTORY_FILE, "utf-8"));
  } catch {
    return [];
  }
}

function saveHistory(list: HistoryItem[]) {
  ensureShareDir();
  writeFileSync(HISTORY_FILE, JSON.stringify(list.slice(0, 50), null, 2), "utf-8");
}

function pushHistory(item: HistoryItem) {
  const list = loadHistory();
  list.unshift(item);
  saveHistory(list);
}

function statusPayload() {
  const cfg = loadShareConfig();
  const tunnelUrl = getTryUrlFromLog();
  return {
    ok: true,
    webRunning: tmuxSessionExists(WEB_SESSION),
    tunnelRunning: tmuxSessionExists(TUNNEL_SESSION),
    config: cfg,
    tunnelUrl,
    fileUrl:
      cfg?.fileRoute && tunnelUrl
        ? `${tunnelUrl}${String(cfg.fileRoute).startsWith("/") ? cfg.fileRoute : `/${cfg.fileRoute}`}`
        : null,
    logTail: getLastLogTail(60),
    now: new Date().toISOString(),
  };
}

function runShare(args: string[]): { ok: boolean; output: string } {
  const result = spawnSync("bun", [SHARE_SCRIPT, ...args], {
    encoding: "utf-8",
  });

  const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
  return { ok: result.status === 0, output };
}

function json(data: unknown, status = 200) {
  return new Response(JSON.stringify(data, null, 2), {
    status,
    headers: {
      "Content-Type": "application/json; charset=utf-8",
      "Cache-Control": "no-store",
    },
  });
}

function recordStop() {
  const cfg = loadShareConfig();
  if (!cfg) return;
  const url = getTryUrlFromLog();
  if (url) {
    pushHistory({
      mode: cfg.mode,
      localPort: cfg.localPort,
      webDir: cfg.webDir,
      filePath: cfg.filePath,
      fileRoute: cfg.fileRoute,
      tunnelUrl: url,
      fileUrl: cfg.fileRoute
        ? `${url}${String(cfg.fileRoute).startsWith("/") ? cfg.fileRoute : `/${cfg.fileRoute}`}`
        : undefined,
      startedAt: cfg.startedAt,
      stoppedAt: new Date().toISOString(),
    });
  }
}

const { host, port } = parsePanelArgs();

const server = Bun.serve({
  port,
  hostname: host,
  async fetch(req) {
    const url = new URL(req.url);

    if (req.method === "GET" && (url.pathname === "/" || url.pathname === "/panel")) {
      const html = readFileSync(PANEL_HTML, "utf-8");
      return new Response(html, { headers: { "Content-Type": "text/html; charset=utf-8" } });
    }

    if (req.method === "GET" && url.pathname === "/api/status") {
      return json(statusPayload());
    }

    if (req.method === "POST" && url.pathname === "/api/start") {
      const body = (await req.json().catch(() => ({} as any))) as any;
      const args: string[] = ["start"];
      if (body?.port) args.push("--port", String(body.port));
      if (body?.dir) args.push("--dir", String(body.dir));
      if (body?.file) args.push("--file", String(body.file));
      if (body?.route) args.push("--route", String(body.route));

      const result = runShare(args);
      return json({ ...result, status: statusPayload() }, result.ok ? 200 : 500);
    }

    if (req.method === "POST" && url.pathname === "/api/stop") {
      recordStop();
      const result = runShare(["stop"]);
      return json({ ...result, status: statusPayload() }, result.ok ? 200 : 500);
    }

    if (req.method === "GET" && url.pathname === "/api/logs") {
      return json({ ok: true, logTail: getLastLogTail(200) });
    }

    if (req.method === "GET" && url.pathname === "/api/history") {
      return json({ ok: true, history: loadHistory() });
    }

    if (req.method === "POST" && url.pathname === "/api/history/clear") {
      saveHistory([]);
      return json({ ok: true });
    }

    return new Response("Not Found", { status: 404 });
  },
});

console.log(`\n✨ CF Share Panel 已启动`);
console.log(`   http://${host}:${server.port}`);
console.log(`   管理接口: /api/status /api/start /api/stop /api/logs\n`);

#!/usr/bin/env bun
// 端口检测工具

import {
  isPortInUse,
  getPortPid,
  getProcessInfo,
  findAvailablePort,
  execSilent,
  confirm,
} from "./lib/utils.ts";

const port = parseInt(process.argv[2], 10) || 8080;

console.log(`🔍 端口检测: ${port}\n`);

if (!isPortInUse(port)) {
  console.log(`✅ 端口 ${port} 可用\n`);
  process.exit(0);
}

const pid = getPortPid(port);
console.log(`❌ 端口 ${port} 已被占用\n`);

if (pid) {
  const info = getProcessInfo(pid);
  console.log("占用进程信息:");
  console.log(`  PID: ${pid}`);
  if (info) {
    console.log(`  命令: ${info.command}`);
    console.log(`  用户: ${info.user}`);
  }
  
  // 尝试获取更多信息
  const cmdline = execSilent(`cat /proc/${pid}/cmdline 2>/dev/null | tr '\\0' ' '`);
  if (cmdline) {
    console.log(`  完整命令: ${cmdline.substring(0, 100)}${cmdline.length > 100 ? "..." : ""}`);
  }
}

// 检查是否为 tmux 会话
const tmuxList = execSilent("tmux list-sessions -F '#{session_name} #{session_id}' 2>/dev/null");
if (tmuxList) {
  console.log("\n当前 tmux 会话:");
  console.log(tmuxList.split("\n").map(l => "  " + l).join("\n"));
}

console.log("\n选项:");
const available = findAvailablePort(port + 1);
if (available) {
  console.log(`  💡 推荐可用端口: ${available}`);
}

const shouldKill = await confirm("\n是否终止占用进程?");
if (shouldKill && pid) {
  console.log(`\n🛑 发送 SIGTERM 到进程 ${pid}...`);
  try {
    process.kill(pid, "SIGTERM");
    await new Promise(r => setTimeout(r, 1500));
    
    if (isPortInUse(port)) {
      console.log("进程未响应，发送 SIGKILL...");
      process.kill(pid, "SIGKILL");
      await new Promise(r => setTimeout(r, 500));
    }
    
    if (isPortInUse(port)) {
      console.log("❌ 无法终止进程（可能需要 sudo）\n");
    } else {
      console.log("✅ 端口已释放\n");
    }
  } catch (e) {
    console.error(`❌ 错误: ${e}\n`);
  }
}

#!/usr/bin/env bun
// 重启 Cloudflare Tunnel

import { execSync } from "child_process";
import * as path from "path";

const SCRIPT_DIR = path.dirname(import.meta.url.replace("file://", ""));

console.log("🔄 重启 Cloudflare Tunnel\n");

// 先停止
try {
  execSync(`bun "${path.join(SCRIPT_DIR, "stop.ts")}"`, { stdio: "inherit" });
} catch {
  // ignore
}

console.log("\n---\n");

// 再启动
try {
  execSync(`bun "${path.join(SCRIPT_DIR, "start.ts")}" ${process.argv.slice(2).join(" ")}`, { stdio: "inherit" });
} catch {
  process.exit(1);
}

#!/usr/bin/env bun
// 通用临时暴露：任意本地端口 / 目录 / 单文件 -> trycloudflare 公网地址

import { execSync } from "child_process";
import * as fs from "fs";
import * as path from "path";
import * as os from "os";
import {
  findAvailablePort,
  isPortInUse,
  tmuxSessionExists,
  killTmuxSession,
  execSilent,
  printStatus,
} from "./lib/utils.ts";

const SHARE_DIR = path.join(os.homedir(), ".cf-tunnel");
const SHARE_FILE = path.join(SHARE_DIR, "share.json");
const SHARE_LOG = path.join(SHARE_DIR, "share-tunnel.log");

const WEB_SESSION = "cf-share-web";
const TUNNEL_SESSION = "cf-share-tunnel";

type ShareConfig = {
  mode: "port" | "dir" | "file";
  localPort: number;
  webDir?: string;
  filePath?: string;
  fileRoute?: string;
  startedAt: string;
};

function ensureShareDir(): void {
  if (!fs.existsSync(SHARE_DIR)) fs.mkdirSync(SHARE_DIR, { recursive: true });
}

function saveShareConfig(cfg: ShareConfig): void {
  ensureShareDir();
  fs.writeFileSync(SHARE_FILE, JSON.stringify(cfg, null, 2), "utf-8");
}

function loadShareConfig(): ShareConfig | null {
  try {
    if (!fs.existsSync(SHARE_FILE)) return null;
    return JSON.parse(fs.readFileSync(SHARE_FILE, "utf-8"));
  } catch {
    return null;
  }
}

function usage() {
  console.log(`
Cloudflare 临时暴露（底层命令）

推荐统一入口：
  bun ~/.pi/agent/skills/cf-tunnel/scripts/cf.ts start --dir ./demos/html

底层用法：
  bun ~/.pi/agent/skills/cf-tunnel/scripts/share.ts start [--port 8766] [--dir ./demos/html] [--file ./demos/html/index.html] [--route /index.html]
  bun ~/.pi/agent/skills/cf-tunnel/scripts/share.ts status
  bun ~/.pi/agent/skills/cf-tunnel/scripts/share.ts stop

说明：
  - start + --port: 仅暴露已有本地端口
  - start + --dir : 自动起本地静态服务并暴露
  - start + --file: 以文件所在目录起服务，并提示文件访问路径
`);
}

function parseArgs() {
  const args = process.argv.slice(2);
  const cmd = args[0] ?? "status";

  let port: number | undefined;
  let dir: string | undefined;
  let file: string | undefined;
  let route: string | undefined;

  for (let i = 1; i < args.length; i++) {
    const a = args[i];
    const b = args[i + 1];
    if (a === "--port" && b) {
      port = parseInt(b, 10);
      i++;
    } else if (a === "--dir" && b) {
      dir = b;
      i++;
    } else if (a === "--file" && b) {
      file = b;
      i++;
    } else if (a === "--route" && b) {
      route = b;
      i++;
    }
  }

  return { cmd, port, dir, file, route };
}

function mustHaveCloudflared() {
  if (!execSilent("which cloudflared")) {
    console.error("❌ 未找到 cloudflared，请先安装");
    process.exit(1);
  }
}

function getTryUrlFromLog(): string | null {
  try {
    if (!fs.existsSync(SHARE_LOG)) return null;
    const content = fs.readFileSync(SHARE_LOG, "utf-8");
    const m = content.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
    return m?.[0] ?? null;
  } catch {
    return null;
  }
}

function startLocalWeb(dir: string, port: number): void {
  if (tmuxSessionExists(WEB_SESSION)) killTmuxSession(WEB_SESSION);

  let serverCmd = "";
  if (execSilent("which python3")) {
    serverCmd = `python3 -m http.server ${port} --bind 0.0.0.0`;
  } else if (execSilent("which bunx")) {
    serverCmd = `bunx serve -p ${port}`;
  } else if (execSilent("which npx")) {
    serverCmd = `npx serve -p ${port}`;
  } else {
    console.error("❌ 未找到可用静态服务工具 (python3/bunx/npx)");
    process.exit(1);
  }

  execSync(`tmux new-session -d -s ${WEB_SESSION} -c \"${dir}\" \"${serverCmd}\"`, { stdio: "inherit" });
}

function startTunnel(port: number): void {
  if (tmuxSessionExists(TUNNEL_SESSION)) killTmuxSession(TUNNEL_SESSION);
  ensureShareDir();
  if (fs.existsSync(SHARE_LOG)) fs.unlinkSync(SHARE_LOG);

  const cmd = `cloudflared tunnel --no-autoupdate --url http://localhost:${port} > \"${SHARE_LOG}\" 2>&1`;
  execSync(`tmux new-session -d -s ${TUNNEL_SESSION} \"${cmd}\"`, { stdio: "inherit" });
}

async function waitTryUrl(timeoutMs = 12000): Promise<string | null> {
  const started = Date.now();
  while (Date.now() - started < timeoutMs) {
    const url = getTryUrlFromLog();
    if (url) return url;
    await new Promise((r) => setTimeout(r, 500));
  }
  return null;
}

function status() {
  const cfg = loadShareConfig();
  const webOn = tmuxSessionExists(WEB_SESSION);
  const tunnelOn = tmuxSessionExists(TUNNEL_SESSION);
  const url = getTryUrlFromLog();

  console.log("\n📊 临时暴露状态\n");
  printStatus(webOn ? "running" : "stopped", `本地服务 (${WEB_SESSION})`);
  printStatus(tunnelOn ? "running" : "stopped", `Cloudflare Tunnel (${TUNNEL_SESSION})`);

  if (cfg) {
    console.log(`\n模式: ${cfg.mode}`);
    console.log(`端口: ${cfg.localPort}`);
    if (cfg.webDir) console.log(`目录: ${cfg.webDir}`);
    if (cfg.filePath) console.log(`文件: ${cfg.filePath}`);
  }

  if (url) {
    console.log(`\n🌐 公网地址: ${url}`);
    if (cfg?.fileRoute) {
      const suffix = cfg.fileRoute.startsWith("/") ? cfg.fileRoute : `/${cfg.fileRoute}`;
      console.log(`📄 文件直达: ${url}${suffix}`);
    }
  } else {
    console.log("\n🌐 公网地址: (等待中或未启动)");
  }
  console.log("");
}

function stop() {
  if (tmuxSessionExists(WEB_SESSION)) killTmuxSession(WEB_SESSION);
  if (tmuxSessionExists(TUNNEL_SESSION)) killTmuxSession(TUNNEL_SESSION);
  printStatus("stopped", "已停止临时暴露会话");
}

async function start() {
  mustHaveCloudflared();
  const { port, dir, file, route } = parseArgs();

  const modes = [port ? 1 : 0, dir ? 1 : 0, file ? 1 : 0].reduce((a, b) => a + b, 0);
  if (modes > 1) {
    console.error("❌ --port / --dir / --file 只能选一个");
    process.exit(1);
  }

  let mode: ShareConfig["mode"] = "port";
  let localPort = port ?? 0;
  let webDir: string | undefined;
  let filePath: string | undefined;
  let fileRoute: string | undefined;

  if (file) {
    const abs = path.resolve(file);
    if (!fs.existsSync(abs)) {
      console.error(`❌ 文件不存在: ${abs}`);
      process.exit(1);
    }
    mode = "file";
    filePath = abs;
    webDir = path.dirname(abs);
    fileRoute = route || `/${path.basename(abs)}`;
    localPort = localPort || findAvailablePort() || 8766;
    startLocalWeb(webDir, localPort);
  } else if (dir) {
    const absDir = path.resolve(dir);
    if (!fs.existsSync(absDir) || !fs.statSync(absDir).isDirectory()) {
      console.error(`❌ 目录不存在: ${absDir}`);
      process.exit(1);
    }
    mode = "dir";
    webDir = absDir;
    localPort = localPort || findAvailablePort() || 8766;
    startLocalWeb(webDir, localPort);
  } else {
    mode = "port";
    localPort = localPort || 8766;
    if (!isPortInUse(localPort)) {
      console.error(`❌ 端口 ${localPort} 未监听，请先启动本地服务，或改用 --dir/--file`);
      process.exit(1);
    }
  }

  startTunnel(localPort);

  const cfg: ShareConfig = {
    mode,
    localPort,
    webDir,
    filePath,
    fileRoute,
    startedAt: new Date().toISOString(),
  };
  saveShareConfig(cfg);

  const url = await waitTryUrl();

  console.log("\n✅ 临时暴露已启动\n");
  console.log(`本地: http://localhost:${localPort}`);
  if (url) {
    console.log(`公网: ${url}`);
    if (fileRoute) {
      const suffix = fileRoute.startsWith("/") ? fileRoute : `/${fileRoute}`;
      console.log(`文件: ${url}${suffix}`);
    }
  } else {
    console.log("公网: 还在建立中，稍后执行 status 查看");
  }
  console.log("\n管理命令:");
  console.log(`  bun ~/.pi/agent/skills/cf-tunnel/scripts/cf.ts status`);
  console.log(`  bun ~/.pi/agent/skills/cf-tunnel/scripts/cf.ts stop --share`);
  console.log(`  bun ~/.pi/agent/skills/cf-tunnel/scripts/share.ts status  # 底层命令`);
}

(async () => {
  const { cmd } = parseArgs();

  if (cmd === "start") {
    await start();
  } else if (cmd === "status") {
    status();
  } else if (cmd === "stop") {
    stop();
  } else if (cmd === "help" || cmd === "--help" || cmd === "-h") {
    usage();
  } else {
    usage();
    process.exit(1);
  }
})();