volute 0.8.3 → 0.10.0

package/dist/{agent-YORVRB6I.js → agent-ECRX44DB.js}

@@ -6,42 +6,42 @@ async function run(args) {
   const subcommand = args[0];
   switch (subcommand) {
     case "create":
-      await import("./create-HGJHLABX.js").then((m) => m.run(args.slice(1)));
+      await import("./create-VBZZNJOG.js").then((m) => m.run(args.slice(1)));
       break;
     case "start":
-      await import("./start-QU73YTJW.js").then((m) => m.run(args.slice(1)));
+      await import("./start-6YRS6FF6.js").then((m) => m.run(args.slice(1)));
       break;
     case "stop":
-      await import("./stop-N7U5N6A7.js").then((m) => m.run(args.slice(1)));
+      await import("./stop-UQSNF4CG.js").then((m) => m.run(args.slice(1)));
       break;
     case "restart":
-      await import("./restart-KVH3TK5N.js").then((m) => m.run(args.slice(1)));
+      await import("./restart-CCYM3MEC.js").then((m) => m.run(args.slice(1)));
       break;
     case "delete":
-      await import("./delete-45TGQC4N.js").then((m) => m.run(args.slice(1)));
+      await import("./delete-BOTVU4YO.js").then((m) => m.run(args.slice(1)));
       break;
     case "list":
-      await import("./status-Q6ZQJXNI.js").then((m) => m.run(args.slice(1)));
+      await import("./status-SIMKH3ZE.js").then((m) => m.run(args.slice(1)));
       break;
     case "status": {
       const rest = args.slice(1);
       if (!rest[0] && process.env.VOLUTE_AGENT) {
         rest.unshift(process.env.VOLUTE_AGENT);
       }
-      await import("./status-Q6ZQJXNI.js").then((m) => m.run(rest));
+      await import("./status-SIMKH3ZE.js").then((m) => m.run(rest));
       break;
     }
     case "logs": {
       const rest = args.slice(1);
       const logsArgs = transformAgentFlag(rest);
-      await import("./logs-TZB3MTLZ.js").then((m) => m.run(logsArgs));
+      await import("./logs-APWVWGNX.js").then((m) => m.run(logsArgs));
       break;
     }
     case "upgrade":
-      await import("./upgrade-CZF6PN7Y.js").then((m) => m.run(args.slice(1)));
+      await import("./upgrade-RSE4CZNE.js").then((m) => m.run(args.slice(1)));
       break;
     case "import":
-      await import("./import-CNEDF3TD.js").then((m) => m.run(args.slice(1)));
+      await import("./import-2BZUWT23.js").then((m) => m.run(args.slice(1)));
       break;
     case "--help":
     case "-h":

package/dist/{agent-manager-CMMH5KQQ.js → agent-manager-MRHHKAB6.js}

@@ -3,9 +3,9 @@ import {
   AgentManager,
   getAgentManager,
   initAgentManager
-} from "./chunk-W6TMWYU3.js";
-import "./chunk-QF22MYDJ.js";
+} from "./chunk-WV4W7BAT.js";
 import "./chunk-IQXBMFZG.js";
+import "./chunk-QF22MYDJ.js";
 import "./chunk-DP2DX4WV.js";
 import "./chunk-K3NQKI34.js";
 export {

package/dist/api-client-YPKOZP2O.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
+import "./chunk-K3NQKI34.js";
+export {
+  getClient,
+  urlOf
+};

package/dist/{channel-RDGHBFSI.js → channel-2WHBRDTD.js}

@@ -2,25 +2,17 @@
 import {
   resolveAgentName
 } from "./chunk-AZEL2IEK.js";
-import {
-  CHANNELS,
-  getChannelDriver
-} from "./chunk-LIPPXNIE.js";
-import {
-  loadMergedEnv
-} from "./chunk-QF22MYDJ.js";
-import {
-  writeChannelEntry
-} from "./chunk-N6MLQ26B.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-23L3MKEV.js";
+} from "./chunk-STOEJOJO.js";
+import "./chunk-DP2DX4WV.js";
 import {
-  agentDir
-} from "./chunk-DP2DX4WV.js";
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/channel.ts
@@ -72,17 +64,20 @@ async function readChannel(args) {
   }
   const agentName = resolveAgentName(flags);
   const { platform } = parseUri(uri);
-  const driver = requireDriver(platform);
-  const dir = agentDir(agentName);
-  const env = { ...loadMergedEnv(agentName), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
-  try {
-    const limit = flags.limit ?? 20;
-    const output = await driver.read(env, uri, limit);
-    console.log(output);
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
+  const limit = flags.limit ?? 20;
+  const client = getClient();
+  const url = client.api.agents[":name"].channels.read.$url({ param: { name: agentName } });
+  url.searchParams.set("platform", platform);
+  url.searchParams.set("uri", uri);
+  url.searchParams.set("limit", String(limit));
+  const res = await daemonFetch(urlOf(url));
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
     process.exit(1);
   }
+  const output = await res.text();
+  console.log(output);
 }
 async function listChannels(args) {
   const { positional, flags } = parseArgs(args, {
@@ -90,29 +85,27 @@ async function listChannels(args) {
   });
   const platform = positional[0];
   const agentName = resolveAgentName(flags);
-  const dir = agentDir(agentName);
-  const env = { ...loadMergedEnv(agentName), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
-  const platforms = platform ? [platform] : Object.keys(CHANNELS);
-  for (const p of platforms) {
-    const driver = getChannelDriver(p);
-    if (!driver?.listConversations) continue;
-    try {
-      const convs = await driver.listConversations(env);
-      for (const conv of convs) {
-        writeChannelEntry(agentName, conv.id, {
-          platformId: conv.platformId,
-          platform: p,
-          name: conv.name,
-          type: conv.type
-        });
-        const parts = [conv.id.padEnd(24), conv.name.padEnd(28), conv.type];
-        if (conv.participantCount != null) {
-          parts.push(String(conv.participantCount));
-        }
-        console.log(parts.join("  "));
+  const client = getClient();
+  const url = client.api.agents[":name"].channels.list.$url({ param: { name: agentName } });
+  if (platform) url.searchParams.set("platform", platform);
+  const res = await daemonFetch(urlOf(url));
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
+    process.exit(1);
+  }
+  const results = await res.json();
+  for (const [p, convs] of Object.entries(results)) {
+    for (const conv of convs) {
+      if (conv.error) {
+        console.error(`${p}: ${conv.error}`);
+        continue;
+      }
+      const parts = [conv.id.padEnd(24), conv.name.padEnd(28), conv.type];
+      if (conv.participantCount != null) {
+        parts.push(String(conv.participantCount));
       }
-    } catch (err) {
-      console.error(`${p}: ${err instanceof Error ? err.message : String(err)}`);
+      console.log(parts.join("  "));
     }
   }
 }
@@ -125,23 +118,20 @@ async function listUsers(args) {
     console.error("Usage: volute channel users <platform> [--agent <name>]");
     process.exit(1);
   }
-  const driver = requireDriver(platform);
-  if (!driver.listUsers) {
-    console.error(`Platform ${platform} does not support listing users`);
-    process.exit(1);
-  }
   const agentName = resolveAgentName(flags);
-  const dir = agentDir(agentName);
-  const env = { ...loadMergedEnv(agentName), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
-  try {
-    const users = await driver.listUsers(env);
-    for (const user of users) {
-      console.log(`${user.username.padEnd(20)}  ${user.id.padEnd(20)}  ${user.type ?? ""}`);
-    }
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
+  const client = getClient();
+  const url = client.api.agents[":name"].channels.users.$url({ param: { name: agentName } });
+  url.searchParams.set("platform", platform);
+  const res = await daemonFetch(urlOf(url));
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
     process.exit(1);
   }
+  const users = await res.json();
+  for (const user of users) {
+    console.log(`${user.username.padEnd(20)}  ${user.id.padEnd(20)}  ${user.type ?? ""}`);
+  }
 }
 async function createChannel(args) {
   const { positional, flags } = parseArgs(args, {
@@ -156,22 +146,24 @@ async function createChannel(args) {
     );
     process.exit(1);
   }
-  const driver = requireDriver(platform);
-  if (!driver.createConversation) {
-    console.error(`Platform ${platform} does not support creating conversations`);
-    process.exit(1);
-  }
   const agentName = resolveAgentName(flags);
-  const dir = agentDir(agentName);
-  const env = { ...loadMergedEnv(agentName), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
   const participants = flags.participants.split(",").map((s) => s.trim());
-  try {
-    const slug = await driver.createConversation(env, participants, flags.name);
-    console.log(slug);
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(client.api.agents[":name"].channels.create.$url({ param: { name: agentName } })),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform, participants, name: flags.name })
+    }
+  );
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
     process.exit(1);
   }
+  const data = await res.json();
+  console.log(data.slug);
 }
 async function typingChannel(args) {
   const { positional, flags } = parseArgs(args, {
@@ -184,9 +176,10 @@ async function typingChannel(args) {
   }
   const agentName = resolveAgentName(flags);
   try {
-    const res = await daemonFetch(
-      `/api/agents/${encodeURIComponent(agentName)}/typing?channel=${encodeURIComponent(uri)}`
-    );
+    const client = getClient();
+    const url = client.api.agents[":name"].typing.$url({ param: { name: agentName } });
+    url.searchParams.set("channel", uri);
+    const res = await daemonFetch(urlOf(url));
     if (!res.ok) {
       const body = await res.json().catch(() => ({}));
       console.error(body.error ?? `Server responded with ${res.status}`);
@@ -209,14 +202,6 @@ function parseUri(uri) {
   }
   return { platform: uri.slice(0, colonIdx), channelId: uri.slice(colonIdx + 1) };
 }
-function requireDriver(platform) {
-  const driver = getChannelDriver(platform);
-  if (!driver) {
-    console.error(`No channel driver for platform: ${platform}`);
-    process.exit(1);
-  }
-  return driver;
-}
 export {
   run
 };

package/dist/chunk-4RQBJWQX.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+// src/lib/api-client.ts
+import { hc } from "hono/client";
+var _client;
+function getClient() {
+  _client ??= hc("http://localhost");
+  return _client;
+}
+function urlOf(url) {
+  return url.pathname + url.search;
+}
+
+export {
+  getClient,
+  urlOf
+};

package/dist/{chunk-YNNK4QN2.js → chunk-FYQGANL6.js}

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-STOEJOJO.js";
 import {
   voluteHome
 } from "./chunk-DP2DX4WV.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
 
 // src/commands/down.ts
 import { execFileSync } from "child_process";
@@ -112,8 +119,39 @@ async function run(_args) {
   const result = await stopDaemon();
   if (result.stopped) return;
   if (result.reason === "systemd") {
-    console.error("Volute is managed by a systemd service.");
-    console.error("Use: sudo systemctl stop volute");
+    const client = getClient();
+    await daemonFetch(urlOf(client.api.system.stop.$url()), { method: "POST" });
+    const home = voluteHome();
+    const configPath = resolve(home, "daemon.json");
+    let hostname = "localhost";
+    let port = 4200;
+    if (existsSync(configPath)) {
+      try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        hostname = config.hostname || "localhost";
+        port = config.port ?? 4200;
+      } catch {
+      }
+    }
+    if (hostname === "0.0.0.0") hostname = "127.0.0.1";
+    if (hostname === "::") hostname = "[::1]";
+    const url = new URL("http://localhost");
+    url.hostname = hostname;
+    url.port = String(port);
+    const healthUrl = `${url.origin}/api/health`;
+    const maxWait = 1e4;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+      await new Promise((r) => setTimeout(r, 500));
+      try {
+        await fetch(healthUrl);
+      } catch {
+        console.log("Daemon stopped.");
+        return;
+      }
+    }
+    console.error("Daemon may not have stopped. Check with: volute service status");
+    process.exit(1);
   } else if (result.reason === "orphan") {
     console.error(`Daemon appears to be running on port ${result.port} but PID file is missing.`);
     console.error(`Kill the process manually: lsof -ti :${result.port} | xargs kill`);

package/dist/chunk-R3VB7NF5.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import {
+  agentEnvPath,
+  readEnv,
+  writeEnv
+} from "./chunk-QF22MYDJ.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+
+// src/commands/import.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { basename, resolve as resolve2 } from "path";
+
+// src/lib/volute-config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+function readJson(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readVoluteConfig(agentDir) {
+  const path = resolve(agentDir, "home/.config/volute.json");
+  return readJson(path);
+}
+function writeVoluteConfig(agentDir, config) {
+  const path = resolve(agentDir, "home/.config/volute.json");
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`);
+}
+
+// src/commands/import.ts
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    name: { type: "string" },
+    session: { type: "string" },
+    template: { type: "string" }
+  });
+  const wsDir = resolveWorkspace(positional[0]);
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(urlOf(client.api.agents.import.$url()), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      workspacePath: wsDir,
+      name: flags.name,
+      template: flags.template,
+      sessionPath: flags.session
+    })
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to import agent");
+    process.exit(1);
+  }
+  console.log(`
+${data.message ?? `Imported agent: ${data.name} (port ${data.port})`}`);
+  console.log(`
+  volute agent start ${data.name}`);
+}
+function resolveWorkspace(explicitPath) {
+  if (explicitPath) {
+    const wsDir = resolve2(explicitPath);
+    if (!existsSync2(resolve2(wsDir, "SOUL.md")) || !existsSync2(resolve2(wsDir, "IDENTITY.md"))) {
+      console.error("Not a valid OpenClaw workspace: missing SOUL.md or IDENTITY.md");
+      process.exit(1);
+    }
+    return wsDir;
+  }
+  const cwd = process.cwd();
+  if (existsSync2(resolve2(cwd, "SOUL.md")) && existsSync2(resolve2(cwd, "IDENTITY.md"))) {
+    console.log(`Using workspace: ${cwd}`);
+    return cwd;
+  }
+  const openclawWs = resolve2(homedir(), ".openclaw/workspace");
+  if (existsSync2(resolve2(openclawWs, "SOUL.md")) && existsSync2(resolve2(openclawWs, "IDENTITY.md"))) {
+    console.log(`Using workspace: ${openclawWs}`);
+    return openclawWs;
+  }
+  console.error(
+    "Usage: volute agent import [<workspace-path>] [--name <name>] [--session <path>] [--template <name>]\n\nNo OpenClaw workspace found. Provide a path, run from a workspace, or ensure ~/.openclaw/workspace exists."
+  );
+  process.exit(1);
+}
+function findOpenClawSession(workspaceDir) {
+  const agentsDir = resolve2(homedir(), ".openclaw/agents");
+  if (!existsSync2(agentsDir)) return void 0;
+  const matches = [];
+  try {
+    for (const agent of readdirSync(agentsDir)) {
+      const sessionsDir = resolve2(agentsDir, agent, "sessions");
+      if (!existsSync2(sessionsDir)) continue;
+      for (const file of readdirSync(sessionsDir)) {
+        if (!file.endsWith(".jsonl")) continue;
+        const fullPath = resolve2(sessionsDir, file);
+        if (sessionMatchesWorkspace(fullPath, workspaceDir)) {
+          matches.push({ path: fullPath, mtime: statSync(fullPath).mtimeMs });
+        }
+      }
+    }
+  } catch (err) {
+    console.warn("Warning: error scanning OpenClaw sessions:", err);
+    return void 0;
+  }
+  if (matches.length === 0) return void 0;
+  matches.sort((a, b) => b.mtime - a.mtime);
+  console.log(`Found session: ${matches[0].path}`);
+  return matches[0].path;
+}
+function sessionMatchesWorkspace(sessionPath, workspaceDir) {
+  try {
+    const fd = readFileSync2(sessionPath, "utf-8");
+    const firstLine = fd.slice(0, fd.indexOf("\n"));
+    const header = JSON.parse(firstLine);
+    return header.type === "session" && resolve2(header.cwd) === resolve2(workspaceDir);
+  } catch {
+    return false;
+  }
+}
+function importPiSession(sessionFile, agentDirPath) {
+  const homeDir = resolve2(agentDirPath, "home");
+  const piSessionDir = resolve2(agentDirPath, ".volute/pi-sessions/main");
+  mkdirSync2(piSessionDir, { recursive: true });
+  const content = readFileSync2(sessionFile, "utf-8");
+  const lines = content.trim().split("\n");
+  try {
+    const header = JSON.parse(lines[0]);
+    if (header.type === "session") {
+      header.cwd = homeDir;
+      lines[0] = JSON.stringify(header);
+    }
+  } catch {
+  }
+  const filename = basename(sessionFile);
+  const destPath = resolve2(piSessionDir, filename);
+  writeFileSync2(destPath, `${lines.join("\n")}
+`);
+  console.log(`Imported session (${lines.length} entries)`);
+}
+function importOpenClawConnectors(agentName, agentDirPath) {
+  const configPath = resolve2(homedir(), ".openclaw/openclaw.json");
+  if (!existsSync2(configPath)) return;
+  let config;
+  try {
+    config = JSON.parse(readFileSync2(configPath, "utf-8"));
+  } catch (err) {
+    console.warn("Warning: failed to parse openclaw.json:", err);
+    return;
+  }
+  const discord = config.channels?.discord;
+  if (!discord?.enabled || !discord.token) return;
+  const envPath = agentEnvPath(agentName);
+  const env = readEnv(envPath);
+  env.DISCORD_TOKEN = discord.token;
+  writeEnv(envPath, env);
+  const channelNames = /* @__PURE__ */ new Set();
+  if (discord.guilds) {
+    for (const guild of Object.values(discord.guilds)) {
+      if (!guild.channels) continue;
+      for (const [name, ch] of Object.entries(guild.channels)) {
+        if (ch.allow) channelNames.add(name);
+      }
+    }
+  }
+  const voluteConfig = readVoluteConfig(agentDirPath) ?? {};
+  const connectors = new Set(voluteConfig.connectors ?? []);
+  connectors.add("discord");
+  voluteConfig.connectors = [...connectors];
+  if (channelNames.size > 0) {
+    voluteConfig.discord = { channels: [...channelNames] };
+  }
+  writeVoluteConfig(agentDirPath, voluteConfig);
+  console.log("Imported Discord connector config");
+  if (channelNames.size > 0) {
+    console.log(`Imported followed channels: ${[...channelNames].join(", ")}`);
+  }
+}
+function parseNameFromIdentity(identity) {
+  const match = identity.match(/\*\*Name:\*\*\s*(.+)/);
+  if (match) {
+    const raw = match[1].trim();
+    if (!raw || raw.startsWith("*") || raw.startsWith("(")) return void 0;
+    return raw.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9.-]/g, "");
+  }
+  return void 0;
+}
+
+export {
+  readVoluteConfig,
+  writeVoluteConfig,
+  run,
+  findOpenClawSession,
+  sessionMatchesWorkspace,
+  importPiSession,
+  importOpenClawConnectors,
+  parseNameFromIdentity
+};

package/dist/{chunk-23L3MKEV.js → chunk-STOEJOJO.js}

@@ -9,19 +9,33 @@ import { resolve } from "path";
 function readDaemonConfig() {
   const configPath = resolve(voluteHome(), "daemon.json");
   if (!existsSync(configPath)) {
-    console.error("Volute is not running. Start with: volute up");
+    if (existsSync("/etc/systemd/system/volute.service") && !process.env.VOLUTE_HOME) {
+      console.error("Volute is running as a system service but VOLUTE_HOME is not set.");
+      console.error("Re-run setup to update the CLI wrapper: sudo volute setup");
+      console.error("Then start a new shell or run: source /etc/profile.d/volute.sh");
+    } else {
+      console.error("Volute is not running. Start with: volute up");
+    }
     process.exit(1);
   }
   try {
     return JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch {
-    console.error("Volute is not running. Start with: volute up");
+  } catch (err) {
+    const code = err.code;
+    if (code === "EACCES") {
+      console.error(`Permission denied reading ${configPath}. Try: sudo volute ...`);
+    } else {
+      console.error("Volute is not running. Start with: volute up");
+    }
     process.exit(1);
   }
 }
 function buildUrl(config) {
   const url = new URL("http://localhost");
-  url.hostname = config.hostname || "localhost";
+  let hostname = config.hostname || "localhost";
+  if (hostname === "0.0.0.0") hostname = "127.0.0.1";
+  if (hostname === "::") hostname = "[::1]";
+  url.hostname = hostname;
   url.port = String(config.port);
   return url.origin;
 }

package/dist/cli.js

@@ -9,49 +9,49 @@ if (!process.env.VOLUTE_HOME) {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "--version" || command === "-v") {
-  const { default: pkg } = await import("./package-2S7APQBC.js");
+  const { default: pkg } = await import("./package-ERGXEDAF.js");
   console.log(pkg.version);
   process.exit(0);
 }
 switch (command) {
   case "agent":
-    await import("./agent-YORVRB6I.js").then((m) => m.run(args));
+    await import("./agent-ECRX44DB.js").then((m) => m.run(args));
     break;
   case "send":
-    await import("./send-BNC2S5BY.js").then((m) => m.run(args));
+    await import("./send-X6OQGSD6.js").then((m) => m.run(args));
     break;
   case "history":
-    await import("./history-PXJVYLVY.js").then((m) => m.run(args));
+    await import("./history-NI5QP27M.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-RKXPN5DH.js").then((m) => m.run(args));
+    await import("./variant-7IZF6OWO.js").then((m) => m.run(args));
     break;
   case "connector":
-    await import("./connector-ZP6MEFF4.js").then((m) => m.run(args));
+    await import("./connector-L2HBLZBW.js").then((m) => m.run(args));
     break;
   case "channel":
-    await import("./channel-RDGHBFSI.js").then((m) => m.run(args));
+    await import("./channel-2WHBRDTD.js").then((m) => m.run(args));
     break;
   case "schedule":
-    await import("./schedule-HCUCBNQI.js").then((m) => m.run(args));
+    await import("./schedule-E4MFGYSA.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-KMNYGVZ2.js").then((m) => m.run(args));
+    await import("./env-CGORIKVF.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-RZJMSVQS.js").then((m) => m.run(args));
+    await import("./up-MNNPCMFF.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-4DGRZRJU.js").then((m) => m.run(args));
+    await import("./down-4LIQG3CE.js").then((m) => m.run(args));
     break;
   case "restart":
-    await import("./daemon-restart-IMNCBWFV.js").then((m) => m.run(args));
+    await import("./daemon-restart-QCLR6ZZV.js").then((m) => m.run(args));
     break;
   case "setup":
-    await import("./setup-7SPMWF2O.js").then((m) => m.run(args));
+    await import("./setup-ABMZK6LS.js").then((m) => m.run(args));
     break;
   case "service":
-    await import("./service-56CY4S6Z.js").then((m) => m.run(args));
+    await import("./service-OW35VZ5G.js").then((m) => m.run(args));
     break;
   case "update":
     await import("./update-3TGXUTO2.js").then((m) => m.run(args));