@schuttdev/gigai 0.1.0-beta.20 → 0.1.0-beta.21

package/dist/{chunk-HIKBVSBK.js → chunk-7C3UYEKE.js}

@@ -253,6 +253,7 @@ var ServerConfigSchema = z.object({
   https: HttpsConfigSchema.optional()
 });
 var GigaiConfigSchema = z.object({
+  serverName: z.string().optional(),
   server: ServerConfigSchema,
   auth: AuthConfigSchema,
   tools: z.array(ToolConfigSchema).default([])

package/dist/{dist-IQVGU6KW.js → dist-BH5MOHNB.js}

@@ -6,7 +6,7 @@ import {
   decrypt,
   encrypt,
   generateEncryptionKey
-} from "./chunk-HIKBVSBK.js";
+} from "./chunk-7C3UYEKE.js";
 
 // ../server/dist/index.mjs
 import { parseArgs } from "util";
@@ -17,6 +17,7 @@ import multipart from "@fastify/multipart";
 import fp from "fastify-plugin";
 import { nanoid } from "nanoid";
 import { randomBytes } from "crypto";
+import { hostname } from "os";
 import { nanoid as nanoid2 } from "nanoid";
 import fp2 from "fastify-plugin";
 import fp3 from "fastify-plugin";
@@ -185,6 +186,7 @@ function validateAndPair(store, code, orgUuid, encryptionKey, serverFingerprint)
 }
 function registerAuthRoutes(server, store, config) {
   const serverFingerprint = randomBytes(16).toString("hex");
+  const serverName = config.serverName ?? hostname();
   server.post("/auth/pair", {
     config: {
       rateLimit: { max: 5, timeWindow: "1 hour" }
@@ -208,7 +210,7 @@ function registerAuthRoutes(server, store, config) {
       config.auth.encryptionKey,
       serverFingerprint
     );
-    return { encryptedToken: JSON.stringify(encryptedToken) };
+    return { encryptedToken: JSON.stringify(encryptedToken), serverName };
   });
   server.post("/auth/connect", {
     config: {
@@ -1131,8 +1133,25 @@ async function runInit() {
       config: { allowlist, allowSudo }
     });
   }
+  let serverName;
+  if (httpsProvider === "tailscale") {
+    const dnsName = await getTailscaleDnsName();
+    if (dnsName) {
+      serverName = dnsName.split(".")[0];
+    }
+  } else if (httpsProvider === "cloudflare") {
+    serverName = await input({
+      message: "Server name (identifies this machine):",
+      required: true
+    });
+  }
+  if (!serverName) {
+    const { hostname: osHostname } = await import("os");
+    serverName = osHostname();
+  }
   const encryptionKey = generateEncryptionKey();
   const config = {
+    serverName,
     server: {
       port,
       host: "0.0.0.0",

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   decodeJWTPayload
-} from "./chunk-HIKBVSBK.js";
+} from "./chunk-7C3UYEKE.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -29,9 +29,26 @@ function getConfigPath() {
 async function readConfig() {
   try {
     const raw = await readFile(getConfigPath(), "utf8");
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    if (parsed.server && parsed.token && !parsed.servers) {
+      const name = deriveServerName(parsed.server);
+      const migrated = {
+        activeServer: name,
+        servers: {
+          [name]: {
+            server: parsed.server,
+            token: parsed.token,
+            sessionToken: parsed.sessionToken,
+            sessionExpiresAt: parsed.sessionExpiresAt
+          }
+        }
+      };
+      await writeConfig(migrated);
+      return migrated;
+    }
+    return { activeServer: parsed.activeServer, servers: parsed.servers ?? {} };
   } catch {
-    return {};
+    return { servers: {} };
   }
 }
 async function writeConfig(config) {
@@ -39,11 +56,47 @@ async function writeConfig(config) {
   await mkdir(dir, { recursive: true });
   await writeFile(getConfigPath(), JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
-async function updateConfig(updates) {
+function getActiveEntry(config) {
+  if (!config.activeServer || !config.servers[config.activeServer]) return void 0;
+  return { name: config.activeServer, entry: config.servers[config.activeServer] };
+}
+async function addServer(name, server, token) {
+  const config = await readConfig();
+  for (const [existingName, entry] of Object.entries(config.servers)) {
+    if (normalizeUrl(entry.server) === normalizeUrl(server)) {
+      config.servers[existingName] = { server, token };
+      config.activeServer = existingName;
+      await writeConfig(config);
+      return;
+    }
+  }
+  config.servers[name] = { server, token };
+  config.activeServer = name;
+  await writeConfig(config);
+}
+async function updateServerSession(name, sessionToken, sessionExpiresAt) {
   const config = await readConfig();
-  Object.assign(config, updates);
+  const entry = config.servers[name];
+  if (!entry) return;
+  entry.sessionToken = sessionToken;
+  entry.sessionExpiresAt = sessionExpiresAt;
   await writeConfig(config);
-  return config;
+}
+function deriveServerName(url) {
+  try {
+    const hostname = new URL(url).hostname;
+    return hostname.split(".")[0];
+  } catch {
+    return "default";
+  }
+}
+function normalizeUrl(url) {
+  try {
+    const u = new URL(url);
+    return u.hostname.toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
 }
 
 // src/identity.ts
@@ -193,56 +246,42 @@ function createHttpClient(serverUrl, sessionToken) {
 }
 
 // src/connect.ts
-async function connect() {
+async function connect(serverName) {
   const config = await readConfig();
-  if (!config.server) {
-    throw new Error("No server configured. Run 'gigai pair' first.");
+  if (serverName) {
+    if (!config.servers[serverName]) {
+      const available = Object.keys(config.servers);
+      throw new Error(
+        available.length > 0 ? `Unknown server "${serverName}". Available: ${available.join(", ")}` : `No servers configured. Run 'gigai pair' first.`
+      );
+    }
+    config.activeServer = serverName;
+    await writeConfig(config);
   }
-  if (!config.token) {
-    throw new Error("No auth token found. Run 'gigai pair' first.");
+  const active = getActiveEntry(config);
+  if (!active) {
+    throw new Error("No server configured. Run 'gigai pair' first.");
   }
-  if (config.sessionToken && config.sessionExpiresAt) {
-    if (Date.now() < config.sessionExpiresAt - 5 * 60 * 1e3) {
-      return { serverUrl: config.server, sessionToken: config.sessionToken };
+  const { name, entry } = active;
+  if (entry.sessionToken && entry.sessionExpiresAt) {
+    if (Date.now() < entry.sessionExpiresAt - 5 * 60 * 1e3) {
+      return { serverUrl: entry.server, sessionToken: entry.sessionToken };
     }
   }
   const orgUuid = getOrgUUID();
-  const http = createHttpClient(config.server);
+  const http = createHttpClient(entry.server);
   const res = await http.post("/auth/connect", {
-    encryptedToken: config.token,
+    encryptedToken: entry.token,
     orgUuid
   });
-  await updateConfig({
-    sessionToken: res.sessionToken,
-    sessionExpiresAt: res.expiresAt
-  });
-  return { serverUrl: config.server, sessionToken: res.sessionToken };
+  await updateServerSession(name, res.sessionToken, res.expiresAt);
+  return { serverUrl: entry.server, sessionToken: res.sessionToken };
 }
 
-// src/pair.ts
-async function pair(code, serverUrl) {
-  const orgUuid = getOrgUUID();
-  const http = createHttpClient(serverUrl);
-  const res = await http.post("/auth/pair", {
-    pairingCode: code,
-    orgUuid
-  });
-  await updateConfig({
-    server: serverUrl,
-    token: res.encryptedToken,
-    sessionToken: void 0,
-    sessionExpiresAt: void 0
-  });
-  console.log("Paired successfully!\n");
-  const tokenStr = JSON.stringify(res.encryptedToken);
-  const skillMd = generateSkill(serverUrl, tokenStr);
-  console.log("Save the following as a Claude Desktop skill:\n");
-  console.log("\u2500".repeat(50));
-  console.log(skillMd);
-  console.log("\u2500".repeat(50));
-}
-function generateSkill(serverUrl, token) {
-  return `---
+// src/skill.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import "path";
+var SKILL_MD = `---
 name: gigai
 description: Access tools on the user's machine via the gigai CLI
 ---
@@ -251,21 +290,12 @@ description: Access tools on the user's machine via the gigai CLI
 
 You have access to tools running on the user's local machine through the gigai CLI. This CLI proxies commands over HTTPS to a server on the user's machine.
 
-## Setup (run once per session)
-
-Before using any gigai commands, you must install and configure the CLI in your code execution environment. Run this setup block:
+## Setup (run once per conversation)
 
 \`\`\`bash
 npm install -g @schuttdev/gigai 2>/dev/null
-
 mkdir -p ~/.gigai
-cat > ~/.gigai/config.json << 'GIGAI_EOF'
-{
-  "server": "${serverUrl}",
-  "token": ${token}
-}
-GIGAI_EOF
-
+cp /mnt/skills/user/gigai/config.json ~/.gigai/config.json
 gigai connect
 \`\`\`
 
@@ -278,14 +308,26 @@ If \`gigai connect\` succeeds, you are ready to use tools. If it fails, tell the
 gigai list
 \`\`\`
 
+### Run a tool
+\`\`\`bash
+gigai <tool-name> [args...]
+\`\`\`
+
+Examples:
+\`\`\`bash
+gigai shell date
+gigai fs list Documents
+gigai shell whoami
+\`\`\`
+
 ### Get help for a tool
 \`\`\`bash
 gigai help <tool-name>
 \`\`\`
 
-### Run a tool
+### Switch server (if multiple are configured)
 \`\`\`bash
-gigai <tool-name> [args...]
+gigai connect <server-name>
 \`\`\`
 
 ### File transfer
@@ -296,15 +338,148 @@ gigai download <id> <dest>
 
 ## Important
 
-- Always run the setup block before first use in a new session
+- Always run the setup block before first use in a new conversation
 - All commands execute on the **user's machine**, not in this sandbox
 - If you get auth errors, run \`gigai connect\` to refresh the session
 - Tools are scoped to what the user has configured \u2014 if a tool is missing, tell the user
 `;
+async function generateSkillZip(serverName, serverUrl, token) {
+  let skillConfig = { servers: {} };
+  try {
+    const raw = await readFile2("/mnt/skills/user/gigai/config.json", "utf8");
+    const existing = JSON.parse(raw);
+    if (existing.servers) {
+      skillConfig = existing;
+    }
+  } catch {
+  }
+  let merged = false;
+  for (const [name, entry] of Object.entries(skillConfig.servers)) {
+    if (normalizeHost(entry.server) === normalizeHost(serverUrl)) {
+      skillConfig.servers[name] = { server: serverUrl, token };
+      skillConfig.activeServer = name;
+      merged = true;
+      break;
+    }
+  }
+  if (!merged) {
+    skillConfig.servers[serverName] = { server: serverUrl, token };
+    skillConfig.activeServer = serverName;
+  }
+  const configJson = JSON.stringify(skillConfig, null, 2) + "\n";
+  return createZip([
+    { path: "gigai/SKILL.md", data: Buffer.from(SKILL_MD, "utf8") },
+    { path: "gigai/config.json", data: Buffer.from(configJson, "utf8") }
+  ]);
+}
+async function writeSkillZip(zip) {
+  const outputsDir = "/mnt/user-data/outputs";
+  try {
+    await mkdir2(outputsDir, { recursive: true });
+    const outPath = `${outputsDir}/gigai.zip`;
+    await writeFile2(outPath, zip);
+    return outPath;
+  } catch {
+    const outPath = "gigai.zip";
+    await writeFile2(outPath, zip);
+    return outPath;
+  }
+}
+function normalizeHost(url) {
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+}
+var crc32Table = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+  let c = i;
+  for (let j = 0; j < 8; j++) {
+    c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+  }
+  crc32Table[i] = c >>> 0;
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (const byte of data) {
+    crc = crc >>> 8 ^ crc32Table[(crc ^ byte) & 255];
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function createZip(entries) {
+  const parts = [];
+  const centralParts = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const name = Buffer.from(entry.path, "utf8");
+    const checksum = crc32(entry.data);
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(67324752, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0, 6);
+    local.writeUInt16LE(0, 8);
+    local.writeUInt16LE(0, 10);
+    local.writeUInt16LE(0, 12);
+    local.writeUInt32LE(checksum, 14);
+    local.writeUInt32LE(entry.data.length, 18);
+    local.writeUInt32LE(entry.data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+    parts.push(local, name, entry.data);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(33639248, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(0, 8);
+    central.writeUInt16LE(0, 10);
+    central.writeUInt16LE(0, 12);
+    central.writeUInt16LE(0, 14);
+    central.writeUInt32LE(checksum, 16);
+    central.writeUInt32LE(entry.data.length, 20);
+    central.writeUInt32LE(entry.data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(offset, 42);
+    centralParts.push(central, name);
+    offset += 30 + name.length + entry.data.length;
+  }
+  const centralDir = Buffer.concat(centralParts);
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(101010256, 0);
+  eocd.writeUInt16LE(0, 4);
+  eocd.writeUInt16LE(0, 6);
+  eocd.writeUInt16LE(entries.length, 8);
+  eocd.writeUInt16LE(entries.length, 10);
+  eocd.writeUInt32LE(centralDir.length, 12);
+  eocd.writeUInt32LE(offset, 16);
+  eocd.writeUInt16LE(0, 20);
+  return Buffer.concat([...parts, centralDir, eocd]);
+}
+
+// src/pair.ts
+async function pair(code, serverUrl) {
+  const orgUuid = getOrgUUID();
+  const http = createHttpClient(serverUrl);
+  const res = await http.post("/auth/pair", {
+    pairingCode: code,
+    orgUuid
+  });
+  await addServer(res.serverName, serverUrl, res.encryptedToken);
+  console.log(`Paired with "${res.serverName}" successfully!
+`);
+  const zip = await generateSkillZip(res.serverName, serverUrl, res.encryptedToken);
+  const outPath = await writeSkillZip(zip);
+  console.log(`Skill zip written to: ${outPath}`);
+  console.log("Upload this file as a skill in Claude Desktop (Settings \u2192 Customize \u2192 Upload Skill).");
 }
 
 // src/discover.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 var MANIFEST_TTL = 5 * 60 * 1e3;
@@ -314,7 +489,7 @@ function getManifestPath() {
 }
 async function fetchTools(http) {
   try {
-    const raw = await readFile2(getManifestPath(), "utf8");
+    const raw = await readFile3(getManifestPath(), "utf8");
     const cache = JSON.parse(raw);
     if (Date.now() - cache.fetchedAt < MANIFEST_TTL) {
       return cache.tools;
@@ -324,9 +499,9 @@ async function fetchTools(http) {
   const res = await http.get("/tools");
   try {
     const dir = process.env.GIGAI_CONFIG_DIR ?? join2(homedir2(), ".gigai");
-    await mkdir2(dir, { recursive: true });
+    await mkdir3(dir, { recursive: true });
     const cache = { tools: res.tools, fetchedAt: Date.now() };
-    await writeFile2(getManifestPath(), JSON.stringify(cache));
+    await writeFile3(getManifestPath(), JSON.stringify(cache));
   } catch {
   }
   return res.tools;
@@ -367,11 +542,11 @@ async function execMcpTool(http, tool, mcpTool, args) {
 }
 
 // src/transfer.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { basename } from "path";
 import { Blob } from "buffer";
 async function upload(http, filePath) {
-  const content = await readFile3(filePath);
+  const content = await readFile4(filePath);
   const filename = basename(filePath);
   const formData = new FormData();
   const blob = new Blob([content]);
@@ -386,7 +561,7 @@ async function upload(http, filePath) {
 async function download(http, id, destPath) {
   const res = await http.getRaw(`/transfer/${encodeURIComponent(id)}`);
   const buffer = Buffer.from(await res.arrayBuffer());
-  await writeFile3(destPath, buffer);
+  await writeFile4(destPath, buffer);
   console.log(`Downloaded to: ${destPath}`);
 }
 
@@ -427,26 +602,32 @@ Usage: ${detail.usage}`);
   }
   return lines.join("\n");
 }
-function formatStatus(connected, serverUrl, sessionExpiresAt) {
-  if (!connected) {
+function formatStatus(config) {
+  const serverNames = Object.keys(config.servers);
+  if (serverNames.length === 0) {
     return "Not connected. Run 'gigai pair <code> <server-url>' to set up.";
   }
-  const lines = [`Connected to: ${serverUrl}`];
-  if (sessionExpiresAt) {
-    const remaining = sessionExpiresAt - Date.now();
-    if (remaining > 0) {
-      const mins = Math.floor(remaining / 6e4);
-      lines.push(`Session expires in: ${mins} minutes`);
-    } else {
-      lines.push("Session expired. Will auto-renew on next command.");
+  const lines = [];
+  for (const name of serverNames) {
+    const entry = config.servers[name];
+    const active = name === config.activeServer ? " (active)" : "";
+    lines.push(`  ${name}${active}  ${entry.server}`);
+    if (entry.sessionExpiresAt) {
+      const remaining = entry.sessionExpiresAt - Date.now();
+      if (remaining > 0) {
+        lines.push(`    Session expires in ${Math.floor(remaining / 6e4)} minutes`);
+      } else {
+        lines.push("    Session expired \u2014 will auto-renew on next command");
+      }
     }
   }
-  return lines.join("\n");
+  return `Servers:
+${lines.join("\n")}`;
 }
 
 // src/index.ts
 var mode = detectMode();
-var CLIENT_COMMANDS = /* @__PURE__ */ new Set([
+var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "pair",
   "connect",
   "list",
@@ -456,37 +637,36 @@ var CLIENT_COMMANDS = /* @__PURE__ */ new Set([
   "download",
   "version",
   "--help",
-  "-h"
+  "-h",
+  "server",
+  "wrap",
+  "unwrap"
 ]);
-if (mode === "client") {
-  const firstArg = process.argv[2];
-  if (firstArg && !firstArg.startsWith("-") && !CLIENT_COMMANDS.has(firstArg)) {
-    const toolName = firstArg;
-    const toolArgs = process.argv.slice(3);
-    try {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
-      const { tool: detail } = await fetchToolDetail(http, toolName);
-      if (detail.type === "mcp") {
-        const mcpToolName = toolArgs[0];
-        if (!mcpToolName) {
-          const toolNames = (detail.mcpTools ?? []).map((t) => `  ${t.name} \u2014 ${t.description}`);
-          console.log(`MCP tools for ${toolName}:
+var firstArg = process.argv[2];
+if (firstArg && !firstArg.startsWith("-") && !KNOWN_COMMANDS.has(firstArg)) {
+  const toolName = firstArg;
+  const toolArgs = process.argv.slice(3);
+  try {
+    const { serverUrl, sessionToken } = await connect();
+    const http = createHttpClient(serverUrl, sessionToken);
+    const { tool: detail } = await fetchToolDetail(http, toolName);
+    if (detail.type === "mcp") {
+      const mcpToolName = toolArgs[0];
+      if (!mcpToolName) {
+        const toolNames = (detail.mcpTools ?? []).map((t) => `  ${t.name} \u2014 ${t.description}`);
+        console.log(`MCP tools for ${toolName}:
 ${toolNames.join("\n")}`);
-        } else {
-          const jsonArg = toolArgs.slice(1).join(" ");
-          const args = jsonArg ? JSON.parse(jsonArg) : {};
-          await execMcpTool(http, toolName, mcpToolName, args);
-        }
       } else {
-        await execTool(http, toolName, toolArgs);
+        const jsonArg = toolArgs.slice(1).join(" ");
+        const args = jsonArg ? JSON.parse(jsonArg) : {};
+        await execMcpTool(http, toolName, mcpToolName, args);
       }
-    } catch (e) {
-      console.error(`Error: ${e.message}`);
-      process.exitCode = 1;
+    } else {
+      await execTool(http, toolName, toolArgs);
     }
-  } else {
-    runCitty();
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exitCode = 1;
   }
 } else {
   runCitty();
@@ -504,8 +684,11 @@ function runCitty() {
   });
   const connectCommand = defineCommand({
     meta: { name: "connect", description: "Establish a session with the server" },
-    async run() {
-      const { serverUrl } = await connect();
+    args: {
+      name: { type: "positional", description: "Server name (optional)", required: false }
+    },
+    async run({ args }) {
+      const { serverUrl } = await connect(args.name);
       console.log(`Connected to ${serverUrl}`);
     }
   });
@@ -534,8 +717,7 @@ function runCitty() {
     meta: { name: "status", description: "Show connection status" },
     async run() {
       const config = await readConfig();
-      const connected = Boolean(config.server && config.token);
-      console.log(formatStatus(connected, config.server, config.sessionExpiresAt));
+      console.log(formatStatus(config));
     }
   });
   const uploadCommand = defineCommand({
@@ -577,7 +759,7 @@ function runCitty() {
           dev: { type: "boolean", description: "Development mode (no HTTPS)" }
         },
         async run({ args }) {
-          const { startServer } = await import("./dist-IQVGU6KW.js");
+          const { startServer } = await import("./dist-BH5MOHNB.js");
           const extraArgs = [];
           if (args.config) extraArgs.push("--config", args.config);
           if (args.dev) extraArgs.push("--dev");
@@ -588,7 +770,7 @@ function runCitty() {
       init: defineCommand({
         meta: { name: "init", description: "Interactive setup wizard" },
         async run() {
-          const { runInit } = await import("./dist-IQVGU6KW.js");
+          const { runInit } = await import("./dist-BH5MOHNB.js");
           await runInit();
         }
       }),
@@ -598,7 +780,7 @@ function runCitty() {
           config: { type: "string", alias: "c", description: "Config file path" }
         },
         async run({ args }) {
-          const { generateServerPairingCode } = await import("./dist-IQVGU6KW.js");
+          const { generateServerPairingCode } = await import("./dist-BH5MOHNB.js");
           await generateServerPairingCode(args.config);
         }
       }),
@@ -608,14 +790,14 @@ function runCitty() {
           config: { type: "string", alias: "c", description: "Config file path" }
         },
         async run({ args }) {
-          const { installDaemon } = await import("./dist-IQVGU6KW.js");
+          const { installDaemon } = await import("./dist-BH5MOHNB.js");
           await installDaemon(args.config);
         }
       }),
       uninstall: defineCommand({
         meta: { name: "uninstall", description: "Remove background service" },
         async run() {
-          const { uninstallDaemon } = await import("./dist-IQVGU6KW.js");
+          const { uninstallDaemon } = await import("./dist-BH5MOHNB.js");
           await uninstallDaemon();
         }
       }),
@@ -666,21 +848,21 @@ function runCitty() {
       cli: defineCommand({
         meta: { name: "cli", description: "Wrap a CLI command" },
         async run() {
-          const { wrapCli } = await import("./dist-IQVGU6KW.js");
+          const { wrapCli } = await import("./dist-BH5MOHNB.js");
           await wrapCli();
         }
       }),
       mcp: defineCommand({
         meta: { name: "mcp", description: "Wrap an MCP server" },
         async run() {
-          const { wrapMcp } = await import("./dist-IQVGU6KW.js");
+          const { wrapMcp } = await import("./dist-BH5MOHNB.js");
           await wrapMcp();
         }
       }),
       script: defineCommand({
         meta: { name: "script", description: "Wrap a script" },
         async run() {
-          const { wrapScript } = await import("./dist-IQVGU6KW.js");
+          const { wrapScript } = await import("./dist-BH5MOHNB.js");
           await wrapScript();
         }
       }),
@@ -690,7 +872,7 @@ function runCitty() {
           path: { type: "positional", description: "Path to config file", required: true }
         },
         async run({ args }) {
-          const { wrapImport } = await import("./dist-IQVGU6KW.js");
+          const { wrapImport } = await import("./dist-BH5MOHNB.js");
           await wrapImport(args.path);
         }
       })
@@ -702,7 +884,7 @@ function runCitty() {
       name: { type: "positional", description: "Tool name", required: true }
     },
     async run({ args }) {
-      const { unwrapTool } = await import("./dist-IQVGU6KW.js");
+      const { unwrapTool } = await import("./dist-BH5MOHNB.js");
       await unwrapTool(args.name);
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schuttdev/gigai",
-  "version": "0.1.0-beta.20",
+  "version": "0.1.0-beta.21",
   "type": "module",
   "bin": {
     "gigai": "dist/index.js"