panopticon-cli 0.5.3 → 0.5.6

package/dist/chunk-GUV2EPBG.js

@@ -0,0 +1,692 @@
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-ZHC57RCV.js";
+
+// src/lib/remote/fly-api.ts
+function createFlyApiClient(token) {
+  const tok = token ?? process.env.FLY_API_TOKEN;
+  if (!tok) {
+    throw new Error(
+      "Fly API token not found. Set FLY_API_TOKEN environment variable or run: fly auth login"
+    );
+  }
+  return new FlyApiClient(tok);
+}
+var FlyApiError, BASE_URL, FlyApiClient;
+var init_fly_api = __esm({
+  "src/lib/remote/fly-api.ts"() {
+    "use strict";
+    init_esm_shims();
+    FlyApiError = class extends Error {
+      constructor(message, statusCode, body) {
+        super(message);
+        this.statusCode = statusCode;
+        this.body = body;
+        this.name = "FlyApiError";
+      }
+    };
+    BASE_URL = "https://api.machines.dev/v1";
+    FlyApiClient = class {
+      token;
+      constructor(token) {
+        this.token = token;
+      }
+      async request(method, path, body) {
+        const url = `${BASE_URL}${path}`;
+        const headers = {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        };
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body !== void 0 ? JSON.stringify(body) : void 0
+        });
+        const text = await response.text();
+        if (!response.ok) {
+          throw new FlyApiError(
+            `Fly API error ${response.status} for ${method} ${path}: ${text}`,
+            response.status,
+            text
+          );
+        }
+        if (!text) return void 0;
+        try {
+          return JSON.parse(text);
+        } catch {
+          return text;
+        }
+      }
+      /** Create a machine in an app */
+      async createMachine(appName, name, config) {
+        return this.request("POST", `/apps/${appName}/machines`, {
+          name,
+          config: {
+            image: config.image,
+            env: config.env,
+            guest: config.size ? { cpu_kind: "shared", cpus: 2, memory_mb: config.memory ?? 1024 } : void 0,
+            restart: config.restart ?? { policy: "no" },
+            auto_destroy: config.auto_destroy,
+            metadata: config.metadata
+          },
+          region: config.region
+        });
+      }
+      /** Destroy a machine (force=true for immediate) */
+      async destroyMachine(appName, machineId) {
+        await this.request(
+          "DELETE",
+          `/apps/${appName}/machines/${machineId}?force=true`
+        );
+      }
+      /** Start a stopped machine */
+      async startMachine(appName, machineId) {
+        await this.request(
+          "POST",
+          `/apps/${appName}/machines/${machineId}/start`
+        );
+      }
+      /** Stop a running machine */
+      async stopMachine(appName, machineId, signal, timeout) {
+        await this.request(
+          "POST",
+          `/apps/${appName}/machines/${machineId}/stop`,
+          signal || timeout ? { signal, timeout } : void 0
+        );
+      }
+      /** Get a machine by ID */
+      async getMachine(appName, machineId) {
+        return this.request(
+          "GET",
+          `/apps/${appName}/machines/${machineId}`
+        );
+      }
+      /** List all machines in an app */
+      async listMachines(appName) {
+        const result = await this.request(
+          "GET",
+          `/apps/${appName}/machines`
+        );
+        return result ?? [];
+      }
+      /** Execute a command inside a running machine */
+      async execCommand(appName, machineId, command, timeout = 30) {
+        return this.request(
+          "POST",
+          `/apps/${appName}/machines/${machineId}/exec`,
+          { command, timeout }
+        );
+      }
+      /** Wait for a machine to reach a target state */
+      async waitForState(appName, machineId, state, timeout = 60) {
+        await this.request(
+          "GET",
+          `/apps/${appName}/machines/${machineId}/wait?state=${state}&timeout=${timeout}`
+        );
+      }
+      /** Create a Fly app if it doesn't exist */
+      async ensureApp(appName, orgSlug) {
+        try {
+          await this.request("GET", `/apps/${appName}`);
+        } catch (err) {
+          if (err instanceof FlyApiError && err.statusCode === 404) {
+            await this.request("POST", "/apps", {
+              app_name: appName,
+              org_slug: orgSlug,
+              network: "default"
+            });
+          } else {
+            throw err;
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/lib/remote/fly-provider.ts
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { parse } from "yaml";
+function mapFlyStateToVmStatus(state) {
+  switch (state) {
+    case "started":
+      return "running";
+    case "stopped":
+    case "suspended":
+      return "stopped";
+    case "created":
+    case "replacing":
+      return "creating";
+    case "destroying":
+    case "destroyed":
+      return "deleting";
+    default:
+      return "unknown";
+  }
+}
+function createFlyProvider(config) {
+  return new FlyProvider(config);
+}
+var execAsync, FlyProvider;
+var init_fly_provider = __esm({
+  "src/lib/remote/fly-provider.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fly_api();
+    execAsync = promisify(exec);
+    FlyProvider = class {
+      name = "fly";
+      config;
+      api = null;
+      constructor(config = {}) {
+        this.config = {
+          app: config.app ?? "pan-workspaces",
+          org: config.org ?? "personal",
+          region: config.region ?? "iad",
+          vmSize: config.vmSize ?? "shared-cpu-2x",
+          vmMemory: config.vmMemory ?? 1024,
+          image: config.image ?? "registry.fly.io/pan-workspace:latest",
+          apiToken: config.apiToken ?? process.env.FLY_API_TOKEN ?? ""
+        };
+      }
+      getApi() {
+        if (!this.api) {
+          this.api = createFlyApiClient(this.config.apiToken || void 0);
+        }
+        return this.api;
+      }
+      async isAuthenticated() {
+        if (this.config.apiToken || process.env.FLY_API_TOKEN) {
+          try {
+            await this.getApi().listMachines(this.config.app);
+            return true;
+          } catch {
+          }
+        }
+        try {
+          const result = await execAsync("fly auth whoami", { timeout: 1e4 });
+          return !result.stdout.includes("not logged in");
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Resolve vmName to {appName, machineId} by scanning workspace metadata.
+       * Falls back to listing machines in the app.
+       */
+      async resolveVm(vmName) {
+        const workspacesDir = join(homedir(), ".panopticon", "workspaces");
+        if (existsSync(workspacesDir)) {
+          for (const file of readdirSync(workspacesDir)) {
+            if (!file.endsWith(".yaml")) continue;
+            try {
+              const content = readFileSync(join(workspacesDir, file), "utf-8");
+              const metadata = parse(content);
+              if (metadata.vmName === vmName && metadata.machineId && metadata.appName) {
+                return { appName: metadata.appName, machineId: metadata.machineId };
+              }
+            } catch {
+            }
+          }
+        }
+        const machines = await this.getApi().listMachines(this.config.app);
+        const machine = machines.find((m) => m.name === vmName);
+        if (!machine) {
+          throw new Error(`No Fly machine found for VM name: ${vmName}`);
+        }
+        return { appName: this.config.app, machineId: machine.id };
+      }
+      async createVm(name) {
+        const api = this.getApi();
+        await api.ensureApp(this.config.app, this.config.org);
+        const machine = await api.createMachine(this.config.app, name, {
+          image: this.config.image,
+          size: this.config.vmSize,
+          memory: this.config.vmMemory,
+          region: this.config.region,
+          restart: { policy: "no" },
+          auto_destroy: false
+        });
+        try {
+          await api.waitForState(this.config.app, machine.id, "started", 120);
+        } catch {
+        }
+        return {
+          name,
+          status: mapFlyStateToVmStatus(machine.state),
+          machineId: machine.id,
+          ipAddress: machine.private_ip,
+          created: machine.created_at ? new Date(machine.created_at) : void 0
+        };
+      }
+      async deleteVm(name) {
+        const { appName, machineId } = await this.resolveVm(name);
+        await this.getApi().destroyMachine(appName, machineId);
+      }
+      async listVms() {
+        const machines = await this.getApi().listMachines(this.config.app);
+        return machines.map((m) => ({
+          name: m.name,
+          status: mapFlyStateToVmStatus(m.state),
+          machineId: m.id,
+          ipAddress: m.private_ip,
+          created: m.created_at ? new Date(m.created_at) : void 0
+        }));
+      }
+      async getStatus(name) {
+        try {
+          const { appName, machineId } = await this.resolveVm(name);
+          const machine = await this.getApi().getMachine(appName, machineId);
+          return mapFlyStateToVmStatus(machine.state);
+        } catch {
+          return "unknown";
+        }
+      }
+      async getVmInfo(name) {
+        try {
+          const { appName, machineId } = await this.resolveVm(name);
+          const machine = await this.getApi().getMachine(appName, machineId);
+          return {
+            name,
+            status: mapFlyStateToVmStatus(machine.state),
+            machineId: machine.id,
+            ipAddress: machine.private_ip,
+            created: machine.created_at ? new Date(machine.created_at) : void 0,
+            memoryTotal: machine.config?.guest?.memory_mb
+          };
+        } catch {
+          return null;
+        }
+      }
+      async startVm(name) {
+        const { appName, machineId } = await this.resolveVm(name);
+        await this.getApi().startMachine(appName, machineId);
+        await this.getApi().waitForState(appName, machineId, "started", 60);
+      }
+      async stopVm(name) {
+        const { appName, machineId } = await this.resolveVm(name);
+        await this.getApi().stopMachine(appName, machineId);
+      }
+      /** Execute a command on the VM via Fly Machines exec API */
+      async ssh(vm, command) {
+        const { appName, machineId } = await this.resolveVm(vm);
+        try {
+          const result = await this.getApi().execCommand(
+            appName,
+            machineId,
+            ["/bin/sh", "-c", command],
+            60
+          );
+          return {
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? "",
+            exitCode: result.exit_code ?? 0
+          };
+        } catch (err) {
+          if (err instanceof FlyApiError) {
+            return { stdout: "", stderr: err.message, exitCode: 1 };
+          }
+          throw err;
+        }
+      }
+      /** Stream command output via fly SSH console */
+      async *sshStream(vm, command) {
+        const { appName } = await this.resolveVm(vm);
+        const child = spawn("fly", ["ssh", "console", "-a", appName, "-C", command], {
+          env: { ...process.env }
+        });
+        for await (const chunk of child.stdout) {
+          yield chunk.toString();
+        }
+        for await (const chunk of child.stderr) {
+          yield chunk.toString();
+        }
+        await new Promise((resolve, reject) => {
+          child.on("close", resolve);
+          child.on("error", reject);
+        });
+      }
+      /** Copy a local file to VM using base64 encoding */
+      async copyToVm(vm, localPath, remotePath) {
+        const content = readFileSync(localPath);
+        const b64 = content.toString("base64");
+        const dirPath = remotePath.substring(0, remotePath.lastIndexOf("/"));
+        if (dirPath) {
+          await this.ssh(vm, `mkdir -p ${JSON.stringify(dirPath)}`);
+        }
+        await this.ssh(vm, `echo '${b64}' | base64 -d > ${JSON.stringify(remotePath)}`);
+      }
+      /** Copy a file from VM to local path */
+      async copyFromVm(vm, remotePath, localPath) {
+        const { appName } = await this.resolveVm(vm);
+        await execAsync(
+          `fly ssh sftp get -a ${JSON.stringify(appName)} ${JSON.stringify(remotePath)} ${JSON.stringify(localPath)}`,
+          { timeout: 6e4 }
+        );
+      }
+      /** Expose a port — not supported by Fly.io provider */
+      async exposePort(_vm, _port) {
+        throw new Error(
+          "exposePort is not supported by the Fly.io provider. Configure services in fly.toml or via the Fly Machines API config."
+        );
+      }
+      /** Create a fly proxy tunnel to the machine */
+      async tunnel(vm, remotePort, localPort) {
+        const { appName } = await this.resolveVm(vm);
+        const child = spawn("fly", ["proxy", `${localPort}:${remotePort}`, "-a", appName], {
+          env: { ...process.env }
+        });
+        return {
+          close: () => {
+            child.kill();
+          }
+        };
+      }
+      // ============================================================================
+      // Credential Sync & Configuration (ported from ExeProvider)
+      // ============================================================================
+      /** Sync Claude Code credentials from local macOS Keychain to remote VM */
+      async syncClaudeCredentials(vmName) {
+        try {
+          const { stdout: credentials } = await execAsync(
+            'security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null',
+            { encoding: "utf-8", timeout: 1e4 }
+          );
+          if (!credentials?.trim()) return false;
+          const b64 = Buffer.from(credentials.trim()).toString("base64");
+          await this.ssh(vmName, `mkdir -p ~/.claude && echo '${b64}' | base64 -d > ~/.claude/.credentials.json`);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /** Sync GitHub CLI authentication to the remote VM */
+      async syncGitHubAuth(vmName) {
+        const ghConfigPath = join(homedir(), ".config", "gh", "hosts.yml");
+        if (!existsSync(ghConfigPath)) return false;
+        try {
+          const content = readFileSync(ghConfigPath, "utf-8");
+          const b64 = Buffer.from(content).toString("base64");
+          await this.ssh(vmName, `mkdir -p ~/.config/gh && echo '${b64}' | base64 -d > ~/.config/gh/hosts.yml`);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /** Sync GitLab CLI (glab) authentication to the remote VM */
+      async syncGitLabAuth(vmName) {
+        const glabConfigPath = join(homedir(), ".config", "glab-cli", "config.yml");
+        if (!existsSync(glabConfigPath)) return false;
+        try {
+          const content = readFileSync(glabConfigPath, "utf-8");
+          const b64 = Buffer.from(content).toString("base64");
+          await this.ssh(vmName, `mkdir -p ~/.config/glab-cli && echo '${b64}' | base64 -d > ~/.config/glab-cli/config.yml`);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /** Sync all credentials needed for remote workspace operation */
+      async syncAllCredentials(vmName) {
+        const [claude, github] = await Promise.all([
+          this.syncClaudeCredentials(vmName),
+          this.syncGitHubAuth(vmName)
+        ]);
+        return { claude, github };
+      }
+      /** Install beads CLI (bd) on a remote VM */
+      async installBeads(vmName) {
+        const check = await this.ssh(vmName, "which bd 2>/dev/null");
+        if (check.exitCode === 0 && check.stdout.trim()) return true;
+        const result = await this.ssh(vmName, "npm install -g @beads-dev/beads 2>&1");
+        if (result.exitCode !== 0) {
+          const alt = await this.ssh(
+            vmName,
+            "curl -fsSL https://raw.githubusercontent.com/beads-dev/beads/main/install.sh | bash 2>&1"
+          );
+          return alt.exitCode === 0;
+        }
+        return true;
+      }
+      /** Initialize beads in a workspace on a remote VM */
+      async initBeads(vmName, workspacePath = "/workspace") {
+        const result = await this.ssh(
+          vmName,
+          `cd ${workspacePath} && bd init --prefix PAN 2>&1 || bd init 2>&1`
+        );
+        return result.exitCode === 0;
+      }
+      /** Configure Claude Code on a VM for autonomous operation */
+      async configureClaudeCode(vmName) {
+        await this.ssh(vmName, "mkdir -p ~/.claude");
+        const onboardingScript = `
+import json, os
+path = os.path.expanduser("~/.claude.json")
+data = {}
+if os.path.exists(path):
+    with open(path) as f:
+        data = json.load(f)
+data["hasCompletedOnboarding"] = True
+data["lastOnboardingVersion"] = "2.0.50"
+with open(path, "w") as f:
+    json.dump(data, f, indent=2)
+`;
+        const scriptB64 = Buffer.from(onboardingScript).toString("base64");
+        await this.ssh(vmName, `echo '${scriptB64}' | base64 -d | python3`);
+        const settings = JSON.stringify({
+          theme: "dark",
+          permissions: { defaultMode: "bypassPermissions" }
+        });
+        const settingsB64 = Buffer.from(settings).toString("base64");
+        await this.ssh(vmName, `echo '${settingsB64}' | base64 -d > ~/.claude/settings.json`);
+      }
+      /** Copy essential skills from local ~/.panopticon/skills/ to remote VM */
+      async copySkillsToVm(vmName) {
+        const skillsDir = join(homedir(), ".panopticon", "skills");
+        if (!existsSync(skillsDir)) return;
+        await this.ssh(vmName, "mkdir -p ~/.claude/skills");
+        try {
+          const entries = readdirSync(skillsDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+            const localPath = join(skillsDir, entry.name);
+            const content = readFileSync(localPath, "utf-8");
+            const b64 = Buffer.from(content).toString("base64");
+            await this.ssh(vmName, `echo '${b64}' | base64 -d > ~/.claude/skills/${entry.name}`);
+          }
+        } catch {
+        }
+      }
+      /** Sync beads from remote VM to git: exports JSONL, commits, and pushes */
+      async syncBeadsToGit(vmName, workspacePath = "/workspace", commitMessage) {
+        const msg = commitMessage ?? "chore: sync beads from remote";
+        const exportResult = await this.ssh(
+          vmName,
+          `cd ${workspacePath} && bd export --output .beads/issues.jsonl 2>&1`
+        );
+        if (exportResult.exitCode !== 0) {
+          return false;
+        }
+        const gitResult = await this.ssh(
+          vmName,
+          `cd ${workspacePath} && git add .beads/ && git diff --cached --quiet || (git commit -m ${JSON.stringify(msg)} && git push origin HEAD) 2>&1`
+        );
+        return gitResult.exitCode === 0;
+      }
+      /** Query beads on a remote VM via bd search */
+      async queryBeads(vmName, searchTerm, workspacePath = "/workspace") {
+        const result = await this.ssh(
+          vmName,
+          `cd ${workspacePath} && bd search ${JSON.stringify(searchTerm)} --json 2>/dev/null || echo '[]'`
+        );
+        try {
+          return JSON.parse(result.stdout.trim() || "[]");
+        } catch {
+          return [];
+        }
+      }
+      /** Get the configured app name */
+      getAppName() {
+        return this.config.app;
+      }
+    };
+  }
+});
+
+// src/lib/remote/remote-agents.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { homedir as homedir2 } from "os";
+function getRemoteAgentStateFile(agentId) {
+  return join2(AGENTS_DIR, agentId, "remote-state.json");
+}
+function saveRemoteAgentState(state) {
+  const dir = join2(AGENTS_DIR, state.id);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(getRemoteAgentStateFile(state.id), JSON.stringify(state, null, 2));
+}
+function loadRemoteAgentState(agentId) {
+  const file = getRemoteAgentStateFile(agentId);
+  if (!existsSync2(file)) return null;
+  try {
+    return JSON.parse(readFileSync2(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function remoteSessionExists(provider, vmName, sessionName) {
+  const result = await provider.ssh(vmName, `tmux has-session -t ${sessionName} 2>/dev/null && echo exists || echo not-found`);
+  return result.stdout.trim() === "exists";
+}
+async function spawnRemoteAgent(options) {
+  const { issueId, workspace, model = "claude-sonnet-4-6", prompt } = options;
+  const agentId = `agent-${issueId.toLowerCase()}`;
+  const vmName = workspace.vmName;
+  const fly = createFlyProvider();
+  const vmStatus = await fly.getStatus(vmName);
+  if (vmStatus !== "running") {
+    throw new Error(`VM ${vmName} is not running. Start it with: pan workspace start ${issueId}`);
+  }
+  if (await remoteSessionExists(fly, vmName, agentId)) {
+    throw new Error(`Agent ${agentId} already running on ${vmName}. Use 'pan work tell' to message it.`);
+  }
+  const state = {
+    id: agentId,
+    issueId,
+    vmName,
+    model,
+    status: "starting",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    location: "remote"
+  };
+  saveRemoteAgentState(state);
+  let claudeCmd;
+  if (prompt) {
+    const promptFile = `/workspace/.panopticon/prompts/${agentId}.md`;
+    await fly.ssh(vmName, `mkdir -p /workspace/.panopticon/prompts`);
+    const promptBase64 = Buffer.from(prompt).toString("base64");
+    await fly.ssh(vmName, `echo '${promptBase64}' | base64 -d > ${promptFile}`);
+    const launcherScript = `/workspace/.panopticon/prompts/${agentId}-launcher.sh`;
+    const launcherContent = `#!/bin/bash
+export PATH="/usr/local/bin:$PATH"
+prompt=$(cat "${promptFile}")
+exec claude --dangerously-skip-permissions --model ${model} "$prompt"
+`;
+    const launcherBase64 = Buffer.from(launcherContent).toString("base64");
+    await fly.ssh(vmName, `echo '${launcherBase64}' | base64 -d > ${launcherScript} && chmod +x ${launcherScript}`);
+    claudeCmd = `bash ${launcherScript}`;
+  } else {
+    claudeCmd = `claude --dangerously-skip-permissions --model ${model}`;
+  }
+  const tmuxCmd = `tmux new-session -d -s ${agentId} -c /workspace '${claudeCmd}'`;
+  const result = await fly.ssh(vmName, tmuxCmd);
+  if (result.exitCode !== 0) {
+    state.status = "error";
+    saveRemoteAgentState(state);
+    throw new Error(`Failed to start agent: ${result.stderr}`);
+  }
+  state.status = "running";
+  saveRemoteAgentState(state);
+  return state;
+}
+async function getRemoteAgentOutput(agentId, vmName, lines = 100) {
+  const fly = createFlyProvider();
+  const result = await fly.ssh(vmName, `tmux capture-pane -t ${agentId} -p -S -${lines}`);
+  return result.stdout;
+}
+async function sendToRemoteAgent(agentId, vmName, message) {
+  const fly = createFlyProvider();
+  const escapedMessage = message.replace(/'/g, "'\\''");
+  await fly.ssh(vmName, `tmux send-keys -t ${agentId} '${escapedMessage}'`);
+  await fly.ssh(vmName, `tmux send-keys -t ${agentId} C-m`);
+}
+async function isRemoteAgentRunning(agentId, vmName) {
+  const fly = createFlyProvider();
+  return remoteSessionExists(fly, vmName, agentId);
+}
+async function killRemoteAgent(agentId, vmName) {
+  const fly = createFlyProvider();
+  await fly.ssh(vmName, `tmux kill-session -t ${agentId} 2>/dev/null || true`);
+  const state = loadRemoteAgentState(agentId);
+  if (state) {
+    state.status = "stopped";
+    saveRemoteAgentState(state);
+  }
+}
+async function listRemoteAgents(vmName) {
+  const fly = createFlyProvider();
+  const result = await fly.ssh(vmName, `tmux list-sessions -F "#{session_name}" 2>/dev/null | grep "^agent-" || true`);
+  if (!result.stdout.trim()) {
+    return [];
+  }
+  return result.stdout.trim().split("\n").filter(Boolean);
+}
+async function pollRemoteAgentStatus(agentId, vmName) {
+  const fly = createFlyProvider();
+  const isRunning = await remoteSessionExists(fly, vmName, agentId);
+  if (!isRunning) {
+    return { isRunning: false, lastOutput: "", toolUses: [] };
+  }
+  const output = await getRemoteAgentOutput(agentId, vmName, 50);
+  const toolUses = [];
+  const toolPattern = /(?:Using|Calling|Running)\s+(\w+)\s+tool/gi;
+  let match;
+  while ((match = toolPattern.exec(output)) !== null) {
+    toolUses.push(match[1]);
+  }
+  return {
+    isRunning,
+    lastOutput: output,
+    toolUses
+  };
+}
+var AGENTS_DIR;
+var init_remote_agents = __esm({
+  "src/lib/remote/remote-agents.ts"() {
+    init_esm_shims();
+    init_fly_provider();
+    AGENTS_DIR = join2(homedir2(), ".panopticon", "agents");
+  }
+});
+
+export {
+  createFlyProvider,
+  init_fly_provider,
+  loadRemoteAgentState,
+  spawnRemoteAgent,
+  getRemoteAgentOutput,
+  sendToRemoteAgent,
+  isRemoteAgentRunning,
+  killRemoteAgent,
+  listRemoteAgents,
+  pollRemoteAgentStatus,
+  init_remote_agents
+};
+//# sourceMappingURL=chunk-GUV2EPBG.js.map