@schuttdev/gigai 0.2.6 → 0.2.7

package/dist/index.js

@@ -3,1077 +3,175 @@
 // src/index.ts
 import { defineCommand, runMain } from "citty";
 
-// src/mode.ts
-function detectMode() {
-  if (process.env.GIGAI_MODE === "client") return "client";
-  if (process.env.GIGAI_MODE === "server") return "server";
-  if (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_PROXY_URL || process.env.CLAUDE_CODE_EXEC) {
-    return "client";
-  }
-  return "server";
-}
+// src/version.ts
+var VERSION = "0.2.7";
 
-// src/config.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-function getConfigDir() {
-  return process.env.GIGAI_CONFIG_DIR ?? join(homedir(), ".gigai");
-}
-function getConfigPath() {
-  return join(getConfigDir(), "config.json");
-}
-async function readConfig() {
-  try {
-    const raw = await readFile(getConfigPath(), "utf8");
-    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 { servers: {} };
-  }
-}
-async function writeConfig(config) {
-  const dir = getConfigDir();
-  await mkdir(dir, { recursive: true });
-  await writeFile(getConfigPath(), JSON.stringify(config, null, 2) + "\n", { mode: 384 });
-}
-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();
-  const entry = config.servers[name];
-  if (!entry) return;
-  entry.sessionToken = sessionToken;
-  entry.sessionExpiresAt = sessionExpiresAt;
-  await writeConfig(config);
-}
-function deriveServerName(url) {
-  try {
-    const hostname = new URL(url).hostname;
-    return hostname.split(".")[0];
-  } catch {
-    return "default";
-  }
-}
-function normalizeUrl(url) {
+// src/index.ts
+async function requireServer() {
   try {
-    const u = new URL(url);
-    return u.hostname.toLowerCase();
+    return await import("./dist-MGLETZTT.js");
   } catch {
-    return url.toLowerCase();
-  }
-}
-
-// ../shared/dist/index.mjs
-import { z } from "zod";
-var TailscaleHttpsConfigSchema = z.object({
-  provider: z.literal("tailscale"),
-  funnelPort: z.number().optional()
-});
-var CloudflareHttpsConfigSchema = z.object({
-  provider: z.literal("cloudflare"),
-  tunnelName: z.string(),
-  domain: z.string().optional()
-});
-var ManualHttpsConfigSchema = z.object({
-  provider: z.literal("manual"),
-  certPath: z.string(),
-  keyPath: z.string()
-});
-var HttpsConfigSchema = z.discriminatedUnion("provider", [
-  TailscaleHttpsConfigSchema,
-  CloudflareHttpsConfigSchema,
-  ManualHttpsConfigSchema
-]);
-var CliToolConfigSchema = z.object({
-  type: z.literal("cli"),
-  name: z.string(),
-  command: z.string(),
-  args: z.array(z.string()).optional(),
-  description: z.string(),
-  timeout: z.number().optional(),
-  cwd: z.string().optional(),
-  env: z.record(z.string()).optional()
-});
-var McpToolConfigSchema = z.object({
-  type: z.literal("mcp"),
-  name: z.string(),
-  command: z.string(),
-  args: z.array(z.string()).optional(),
-  description: z.string(),
-  env: z.record(z.string()).optional()
-});
-var ScriptToolConfigSchema = z.object({
-  type: z.literal("script"),
-  name: z.string(),
-  path: z.string(),
-  description: z.string(),
-  timeout: z.number().optional(),
-  interpreter: z.string().optional()
-});
-var BuiltinToolConfigSchema = z.object({
-  type: z.literal("builtin"),
-  name: z.string(),
-  builtin: z.enum(["filesystem", "shell"]),
-  description: z.string(),
-  config: z.record(z.unknown()).optional()
-});
-var ToolConfigSchema = z.discriminatedUnion("type", [
-  CliToolConfigSchema,
-  McpToolConfigSchema,
-  ScriptToolConfigSchema,
-  BuiltinToolConfigSchema
-]);
-var AuthConfigSchema = z.object({
-  encryptionKey: z.string().length(64),
-  pairingTtlSeconds: z.number().default(300),
-  sessionTtlSeconds: z.number().default(14400)
-});
-var ServerConfigSchema = z.object({
-  port: z.number().default(7443),
-  host: z.string().default("0.0.0.0"),
-  https: HttpsConfigSchema.optional()
-});
-var GigaiConfigSchema = z.object({
-  serverName: z.string().optional(),
-  server: ServerConfigSchema,
-  auth: AuthConfigSchema,
-  tools: z.array(ToolConfigSchema).default([])
-});
-function decodeJWTPayload(token) {
-  const parts = token.split(".");
-  if (parts.length !== 3) {
-    throw new Error("Invalid JWT format: expected 3 segments");
+    console.error("Server dependencies not installed.");
+    console.error("Run: npm install -g @schuttdev/gigai");
+    process.exit(1);
   }
-  const payload = parts[1];
-  const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
-  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
-  const decoded = Buffer.from(padded, "base64").toString("utf8");
-  return JSON.parse(decoded);
 }
-
-// src/identity.ts
-function getOrgUUID() {
-  if (process.env.GIGAI_ORG_UUID) {
-    return process.env.GIGAI_ORG_UUID;
-  }
-  const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY || "";
-  const jwtMatch = proxyUrl.match(/jwt_([^@]+)/);
-  if (jwtMatch) {
-    try {
-      const payload = decodeJWTPayload(jwtMatch[1]);
-      if (payload.organization_uuid) {
-        return payload.organization_uuid;
+var serverCommand = defineCommand({
+  meta: { name: "server", description: "Server management commands" },
+  subCommands: {
+    start: defineCommand({
+      meta: { name: "start", description: "Start the gigai server" },
+      args: {
+        config: { type: "string", alias: "c", description: "Config file path" },
+        dev: { type: "boolean", description: "Development mode (no HTTPS)" }
+      },
+      async run({ args }) {
+        const { startServer } = await requireServer();
+        const extraArgs = [];
+        if (args.config) extraArgs.push("--config", args.config);
+        if (args.dev) extraArgs.push("--dev");
+        process.argv.push(...extraArgs);
+        await startServer();
       }
-    } catch {
-    }
-  }
-  const anthropicProxy = process.env.ANTHROPIC_PROXY_URL ?? "";
-  const anthropicJwtMatch = anthropicProxy.match(/([A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/);
-  if (anthropicJwtMatch) {
-    try {
-      const payload = decodeJWTPayload(anthropicJwtMatch[1]);
-      if (payload.organization_uuid) {
-        return payload.organization_uuid;
+    }),
+    init: defineCommand({
+      meta: { name: "init", description: "Interactive setup wizard" },
+      async run() {
+        const { runInit } = await requireServer();
+        await runInit();
       }
-    } catch {
-    }
-  }
-  const apiKey = process.env.ANTHROPIC_API_KEY ?? "";
-  if (apiKey.includes(".")) {
-    try {
-      const payload = decodeJWTPayload(apiKey);
-      if (payload.organization_uuid) {
-        return payload.organization_uuid;
+    }),
+    pair: defineCommand({
+      meta: { name: "pair", description: "Generate a pairing code" },
+      args: {
+        config: { type: "string", alias: "c", description: "Config file path" }
+      },
+      async run({ args }) {
+        const { generateServerPairingCode } = await requireServer();
+        await generateServerPairingCode(args.config);
       }
-    } catch {
-    }
-  }
-  throw new Error(
-    "Cannot determine organization UUID. Set GIGAI_ORG_UUID environment variable."
-  );
-}
-
-// src/http.ts
-async function getProxyDispatcher() {
-  const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
-  if (!proxyUrl) return void 0;
-  try {
-    const undici = await import("undici");
-    return new undici.ProxyAgent(proxyUrl);
-  } catch {
-    return void 0;
-  }
-}
-var _dispatcher = null;
-async function ensureDispatcher() {
-  if (_dispatcher === null) {
-    _dispatcher = await getProxyDispatcher();
-  }
-  return _dispatcher;
-}
-function createHttpClient(serverUrl, sessionToken) {
-  const baseUrl = serverUrl.replace(/\/$/, "");
-  async function request(path, init = {}) {
-    const headers = {
-      ...init.headers ?? {}
-    };
-    if (sessionToken) {
-      headers["Authorization"] = `Bearer ${sessionToken}`;
-    }
-    if (!headers["Content-Type"] && init.body && typeof init.body === "string") {
-      headers["Content-Type"] = "application/json";
-    }
-    const dispatcher = await ensureDispatcher();
-    const fetchOpts = {
-      ...init,
-      headers
-    };
-    if (dispatcher) {
-      fetchOpts.dispatcher = dispatcher;
-    }
-    const res = await fetch(`${baseUrl}${path}`, fetchOpts);
-    if (!res.ok) {
-      let errorBody;
-      try {
-        errorBody = await res.json();
-      } catch {
+    }),
+    install: defineCommand({
+      meta: { name: "install", description: "Install as persistent background service" },
+      args: {
+        config: { type: "string", alias: "c", description: "Config file path" }
+      },
+      async run({ args }) {
+        const { installDaemon } = await requireServer();
+        await installDaemon(args.config);
       }
-      const message = errorBody?.error?.message ?? `HTTP ${res.status}: ${res.statusText}`;
-      throw new Error(message);
-    }
-    return res.json();
-  }
-  return {
-    get(path) {
-      return request(path);
-    },
-    post(path, body) {
-      return request(path, {
-        method: "POST",
-        body: body ? JSON.stringify(body) : void 0
-      });
-    },
-    async postMultipart(path, formData) {
-      const headers = {};
-      if (sessionToken) {
-        headers["Authorization"] = `Bearer ${sessionToken}`;
+    }),
+    uninstall: defineCommand({
+      meta: { name: "uninstall", description: "Remove background service" },
+      async run() {
+        const { uninstallDaemon } = await requireServer();
+        await uninstallDaemon();
       }
-      const dispatcher = await ensureDispatcher();
-      const fetchOpts = {
-        method: "POST",
-        headers,
-        body: formData
-      };
-      if (dispatcher) {
-        fetchOpts.dispatcher = dispatcher;
+    }),
+    stop: defineCommand({
+      meta: { name: "stop", description: "Stop the running gigai server" },
+      async run() {
+        const { execFileSync } = await import("child_process");
+        let pids = [];
+        try {
+          const out = execFileSync("pgrep", ["-f", "gigai server start"], { encoding: "utf8" });
+          pids = out.trim().split("\n").map(Number).filter((pid) => pid && pid !== process.pid);
+        } catch {
+        }
+        if (pids.length === 0) {
+          console.log("No running gigai server found.");
+          return;
+        }
+        for (const pid of pids) {
+          try {
+            process.kill(pid, "SIGTERM");
+            console.log(`Stopped gigai server (PID ${pid})`);
+          } catch (e) {
+            console.error(`Failed to stop PID ${pid}: ${e.message}`);
+          }
+        }
       }
-      const res = await fetch(`${baseUrl}${path}`, fetchOpts);
-      if (!res.ok) {
-        let errorBody;
+    }),
+    status: defineCommand({
+      meta: { name: "status", description: "Show server status" },
+      async run() {
+        console.log("Server status: checking...");
         try {
-          errorBody = await res.json();
+          const res = await fetch("http://localhost:7443/health");
+          const data = await res.json();
+          console.log(`Status: ${data.status}`);
+          console.log(`Version: ${data.version}`);
+          console.log(`Uptime: ${Math.floor(data.uptime / 1e3)}s`);
         } catch {
+          console.log("Server is not running.");
         }
-        throw new Error(errorBody?.error?.message ?? `HTTP ${res.status}`);
       }
-      return res.json();
-    },
-    async getRaw(path) {
-      const headers = {};
-      if (sessionToken) {
-        headers["Authorization"] = `Bearer ${sessionToken}`;
+    })
+  }
+});
+var wrapCommand = defineCommand({
+  meta: { name: "wrap", description: "Register a tool" },
+  subCommands: {
+    cli: defineCommand({
+      meta: { name: "cli", description: "Wrap a CLI command" },
+      async run() {
+        const { wrapCli } = await requireServer();
+        await wrapCli();
       }
-      const dispatcher = await ensureDispatcher();
-      const fetchOpts = { headers };
-      if (dispatcher) {
-        fetchOpts.dispatcher = dispatcher;
+    }),
+    mcp: defineCommand({
+      meta: { name: "mcp", description: "Wrap an MCP server" },
+      async run() {
+        const { wrapMcp } = await requireServer();
+        await wrapMcp();
       }
-      const res = await fetch(`${baseUrl}${path}`, fetchOpts);
-      if (!res.ok) {
-        throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    }),
+    script: defineCommand({
+      meta: { name: "script", description: "Wrap a script" },
+      async run() {
+        const { wrapScript } = await requireServer();
+        await wrapScript();
       }
-      return res;
-    }
-  };
-}
-
-// src/version.ts
-var VERSION = "0.2.6";
-
-// src/connect.ts
-async function connect(serverName) {
-  const config = await readConfig();
-  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);
-  }
-  const active = getActiveEntry(config);
-  if (!active) {
-    throw new Error("No server configured. Run 'gigai pair' first.");
-  }
-  const { name, entry } = active;
-  if (entry.sessionToken && entry.sessionExpiresAt) {
-    if (Date.now() < entry.sessionExpiresAt - 5 * 60 * 1e3) {
-      await checkAndUpdateServer(entry.server, entry.sessionToken);
-      return { serverUrl: entry.server, sessionToken: entry.sessionToken };
-    }
-  }
-  const orgUuid = getOrgUUID();
-  const http = createHttpClient(entry.server);
-  const res = await http.post("/auth/connect", {
-    encryptedToken: entry.token,
-    orgUuid
-  });
-  await updateServerSession(name, res.sessionToken, res.expiresAt);
-  await checkAndUpdateServer(entry.server, res.sessionToken);
-  return { serverUrl: entry.server, sessionToken: res.sessionToken };
-}
-async function checkAndUpdateServer(serverUrl, sessionToken) {
-  try {
-    const http = createHttpClient(serverUrl);
-    const health = await http.get("/health");
-    if (isNewer(VERSION, health.version)) {
-      console.log(`Server is outdated (${health.version} \u2192 ${VERSION}). Updating...`);
-      const authedHttp = createHttpClient(serverUrl, sessionToken);
-      const res = await authedHttp.post("/admin/update");
-      if (res.updated) {
-        console.log("Server updated and restarting.");
-        await waitForServer(serverUrl, 15e3);
-        console.log("Server is back online.");
-      } else {
-        console.log(`Server update failed: ${res.error ?? "unknown error"}`);
+    }),
+    import: defineCommand({
+      meta: { name: "import", description: "Import from claude_desktop_config.json" },
+      args: {
+        path: { type: "positional", description: "Path to config file", required: true }
+      },
+      async run({ args }) {
+        const { wrapImport } = await requireServer();
+        await wrapImport(args.path);
       }
-    }
-  } catch {
+    })
   }
-}
-async function waitForServer(serverUrl, timeoutMs) {
-  const start = Date.now();
-  const http = createHttpClient(serverUrl);
-  await new Promise((r) => setTimeout(r, 2e3));
-  while (Date.now() - start < timeoutMs) {
-    try {
-      await http.get("/health");
-      return;
-    } catch {
-      await new Promise((r) => setTimeout(r, 1e3));
-    }
-  }
-}
-function isNewer(client, server) {
-  const parse = (v) => {
-    const [core, pre] = v.replace(/^v/, "").split("-");
-    const parts = core.split(".").map(Number);
-    const preNum = pre ? parseInt(pre.replace(/\D+/g, "")) || 0 : Infinity;
-    return [...parts, preNum];
-  };
-  const c = parse(client);
-  const s = parse(server);
-  for (let i = 0; i < Math.max(c.length, s.length); i++) {
-    const cv = c[i] ?? 0;
-    const sv = s[i] ?? 0;
-    if (cv > sv) return true;
-    if (cv < sv) return false;
-  }
-  return false;
-}
-
-// 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
----
-
-# gigai
-
-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 conversation)
-
-\`\`\`bash
-npm install -g @schuttdev/gigai --omit=optional 2>/dev/null
-mkdir -p ~/.gigai
-cp /mnt/skills/user/gigai/config.json ~/.gigai/config.json
-gigai connect
-\`\`\`
-
-If \`gigai connect\` succeeds, you are ready to use tools. If it fails, tell the user.
-
-## Usage
-
-### List available tools
-\`\`\`bash
-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>
-\`\`\`
-
-### Switch server (if multiple are configured)
-\`\`\`bash
-gigai connect <server-name>
-\`\`\`
-
-### File transfer
-\`\`\`bash
-gigai upload <file>
-gigai download <id> <dest>
-\`\`\`
-
-## Important
-
-- 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 hasExistingSkill() {
-  try {
-    await readFile2("/mnt/skills/user/gigai/config.json", "utf8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-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 existing = await hasExistingSkill();
-  const zip = await generateSkillZip(res.serverName, serverUrl, res.encryptedToken);
-  const outPath = await writeSkillZip(zip);
-  console.log(`
-Skill zip written to: ${outPath}`);
-  if (existing) {
-    console.log("Skill file updated. Download and re-upload to Claude.");
-  } else {
-    console.log("Upload this file as a skill in Claude (Settings \u2192 Customize \u2192 Upload Skill).");
-  }
-}
-
-// src/discover.ts
-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;
-function getManifestPath() {
-  const dir = process.env.GIGAI_CONFIG_DIR ?? join2(homedir2(), ".gigai");
-  return join2(dir, "tool-manifest.json");
-}
-async function fetchTools(http) {
-  try {
-    const raw = await readFile3(getManifestPath(), "utf8");
-    const cache = JSON.parse(raw);
-    if (Date.now() - cache.fetchedAt < MANIFEST_TTL) {
-      return cache.tools;
-    }
-  } catch {
-  }
-  const res = await http.get("/tools");
-  try {
-    const dir = process.env.GIGAI_CONFIG_DIR ?? join2(homedir2(), ".gigai");
-    await mkdir3(dir, { recursive: true });
-    const cache = { tools: res.tools, fetchedAt: Date.now() };
-    await writeFile3(getManifestPath(), JSON.stringify(cache));
-  } catch {
-  }
-  return res.tools;
-}
-async function fetchToolDetail(http, name) {
-  return http.get(`/tools/${encodeURIComponent(name)}`);
-}
-
-// src/exec.ts
-async function execTool(http, name, args, timeout) {
-  const res = await http.post("/exec", {
-    tool: name,
-    args,
-    timeout
-  });
-  if (res.stdout) process.stdout.write(res.stdout);
-  if (res.stderr) process.stderr.write(res.stderr);
-  process.exitCode = res.exitCode;
-}
-async function execMcpTool(http, tool, mcpTool, args) {
-  const res = await http.post("/exec/mcp", {
-    tool,
-    mcpTool,
-    args
-  });
-  for (const content of res.content) {
-    if (content.type === "text" && content.text) {
-      process.stdout.write(content.text + "\n");
-    } else if (content.type === "image") {
-      console.log(`[Image: ${content.mimeType}]`);
-    } else if (content.type === "resource") {
-      console.log(`[Resource: ${content.mimeType}]`);
-    }
-  }
-  if (res.isError) {
-    process.exitCode = 1;
-  }
-}
-
-// src/transfer.ts
-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 readFile4(filePath);
-  const filename = basename(filePath);
-  const formData = new FormData();
-  const blob = new Blob([content]);
-  formData.append("file", blob, filename);
-  const res = await http.postMultipart(
-    "/transfer/upload",
-    formData
-  );
-  console.log(`Uploaded: ${res.id}`);
-  return res.id;
-}
-async function download(http, id, destPath) {
-  const res = await http.getRaw(`/transfer/${encodeURIComponent(id)}`);
-  const buffer = Buffer.from(await res.arrayBuffer());
-  await writeFile4(destPath, buffer);
-  console.log(`Downloaded to: ${destPath}`);
-}
-
-// src/output.ts
-function formatToolList(tools) {
-  if (tools.length === 0) return "No tools registered.";
-  const maxName = Math.max(...tools.map((t) => t.name.length));
-  const maxType = Math.max(...tools.map((t) => t.type.length));
-  const lines = tools.map((t) => {
-    const name = t.name.padEnd(maxName);
-    const type = t.type.padEnd(maxType);
-    return `  ${name}  ${type}  ${t.description}`;
-  });
-  return `Available tools:
-${lines.join("\n")}`;
-}
-function formatToolDetail(detail) {
-  const lines = [];
-  lines.push(`${detail.name} (${detail.type})`);
-  lines.push(`  ${detail.description}`);
-  if (detail.usage) {
-    lines.push(`
-Usage: ${detail.usage}`);
-  }
-  if (detail.args?.length) {
-    lines.push("\nArguments:");
-    for (const arg of detail.args) {
-      const req = arg.required ? " (required)" : "";
-      const def = arg.default ? ` [default: ${arg.default}]` : "";
-      lines.push(`  ${arg.name}${req}${def} \u2014 ${arg.description}`);
-    }
-  }
-  if (detail.mcpTools?.length) {
-    lines.push("\nMCP Tools:");
-    for (const t of detail.mcpTools) {
-      lines.push(`  ${t.name} \u2014 ${t.description}`);
-    }
-  }
-  return lines.join("\n");
-}
-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 = [];
-  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");
-      }
-    }
+});
+var unwrapCommand = defineCommand({
+  meta: { name: "unwrap", description: "Unregister a tool" },
+  args: {
+    name: { type: "positional", description: "Tool name", required: true }
+  },
+  async run({ args }) {
+    const { unwrapTool } = await requireServer();
+    await unwrapTool(args.name);
   }
-  return `Servers:
-${lines.join("\n")}`;
-}
-
-// src/index.ts
-var mode = detectMode();
-var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
-  "pair",
-  "connect",
-  "list",
-  "help",
-  "status",
-  "upload",
-  "download",
-  "version",
-  "--help",
-  "-h",
-  "server",
-  "wrap",
-  "unwrap"
-]);
-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);
-    }
-  } catch (e) {
-    console.error(`Error: ${e.message}`);
-    process.exitCode = 1;
+});
+var versionCommand = defineCommand({
+  meta: { name: "version", description: "Show version" },
+  run() {
+    console.log(`gigai v${VERSION}`);
   }
-} else {
-  runCitty();
-}
-async function requireServer() {
-  try {
-    return await requireServer();
-  } catch {
-    console.error("Server dependencies not installed.");
-    console.error("Run: npm install -g @schuttdev/gigai");
-    process.exit(1);
+});
+var main = defineCommand({
+  meta: {
+    name: "gigai",
+    version: VERSION,
+    description: "gigai server \u2014 bridge CLI tools to Claude"
+  },
+  subCommands: {
+    server: serverCommand,
+    wrap: wrapCommand,
+    unwrap: unwrapCommand,
+    version: versionCommand
   }
-}
-function runCitty() {
-  const pairCommand = defineCommand({
-    meta: { name: "pair", description: "Pair with a gigai server" },
-    args: {
-      code: { type: "positional", description: "Pairing code", required: true },
-      server: { type: "positional", description: "Server URL", required: true }
-    },
-    async run({ args }) {
-      await pair(args.code, args.server);
-    }
-  });
-  const connectCommand = defineCommand({
-    meta: { name: "connect", description: "Establish a session with the server" },
-    args: {
-      name: { type: "positional", description: "Server name (optional)", required: false }
-    },
-    async run({ args }) {
-      const { serverUrl } = await connect(args.name);
-      console.log(`Connected to ${serverUrl}`);
-    }
-  });
-  const listCommand = defineCommand({
-    meta: { name: "list", description: "List available tools" },
-    async run() {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
-      const tools = await fetchTools(http);
-      console.log(formatToolList(tools));
-    }
-  });
-  const helpCommand = defineCommand({
-    meta: { name: "help", description: "Show help for a tool" },
-    args: {
-      tool: { type: "positional", description: "Tool name", required: true }
-    },
-    async run({ args }) {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
-      const { tool } = await fetchToolDetail(http, args.tool);
-      console.log(formatToolDetail(tool));
-    }
-  });
-  const statusCommand = defineCommand({
-    meta: { name: "status", description: "Show connection status" },
-    async run() {
-      const config = await readConfig();
-      console.log(formatStatus(config));
-    }
-  });
-  const uploadCommand = defineCommand({
-    meta: { name: "upload", description: "Upload a file to the server" },
-    args: {
-      file: { type: "positional", description: "File path", required: true }
-    },
-    async run({ args }) {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
-      await upload(http, args.file);
-    }
-  });
-  const downloadCommand = defineCommand({
-    meta: { name: "download", description: "Download a file from the server" },
-    args: {
-      id: { type: "positional", description: "Transfer ID", required: true },
-      dest: { type: "positional", description: "Destination path", required: true }
-    },
-    async run({ args }) {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
-      await download(http, args.id, args.dest);
-    }
-  });
-  const versionCommand = defineCommand({
-    meta: { name: "version", description: "Show version" },
-    run() {
-      console.log(`gigai v${VERSION}`);
-    }
-  });
-  const serverCommand = defineCommand({
-    meta: { name: "server", description: "Server management commands" },
-    subCommands: {
-      start: defineCommand({
-        meta: { name: "start", description: "Start the gigai server" },
-        args: {
-          config: { type: "string", alias: "c", description: "Config file path" },
-          dev: { type: "boolean", description: "Development mode (no HTTPS)" }
-        },
-        async run({ args }) {
-          const { startServer } = await requireServer();
-          const extraArgs = [];
-          if (args.config) extraArgs.push("--config", args.config);
-          if (args.dev) extraArgs.push("--dev");
-          process.argv.push(...extraArgs);
-          await startServer();
-        }
-      }),
-      init: defineCommand({
-        meta: { name: "init", description: "Interactive setup wizard" },
-        async run() {
-          const { runInit } = await requireServer();
-          await runInit();
-        }
-      }),
-      pair: defineCommand({
-        meta: { name: "pair", description: "Generate a pairing code" },
-        args: {
-          config: { type: "string", alias: "c", description: "Config file path" }
-        },
-        async run({ args }) {
-          const { generateServerPairingCode } = await requireServer();
-          await generateServerPairingCode(args.config);
-        }
-      }),
-      install: defineCommand({
-        meta: { name: "install", description: "Install as persistent background service" },
-        args: {
-          config: { type: "string", alias: "c", description: "Config file path" }
-        },
-        async run({ args }) {
-          const { installDaemon } = await requireServer();
-          await installDaemon(args.config);
-        }
-      }),
-      uninstall: defineCommand({
-        meta: { name: "uninstall", description: "Remove background service" },
-        async run() {
-          const { uninstallDaemon } = await requireServer();
-          await uninstallDaemon();
-        }
-      }),
-      stop: defineCommand({
-        meta: { name: "stop", description: "Stop the running gigai server" },
-        async run() {
-          const { execFileSync } = await import("child_process");
-          let pids = [];
-          try {
-            const out = execFileSync("pgrep", ["-f", "gigai server start"], { encoding: "utf8" });
-            pids = out.trim().split("\n").map(Number).filter((pid) => pid && pid !== process.pid);
-          } catch {
-          }
-          if (pids.length === 0) {
-            console.log("No running gigai server found.");
-            return;
-          }
-          for (const pid of pids) {
-            try {
-              process.kill(pid, "SIGTERM");
-              console.log(`Stopped gigai server (PID ${pid})`);
-            } catch (e) {
-              console.error(`Failed to stop PID ${pid}: ${e.message}`);
-            }
-          }
-        }
-      }),
-      status: defineCommand({
-        meta: { name: "status", description: "Show server status" },
-        async run() {
-          console.log("Server status: checking...");
-          try {
-            const res = await fetch("http://localhost:7443/health");
-            const data = await res.json();
-            console.log(`Status: ${data.status}`);
-            console.log(`Version: ${data.version}`);
-            console.log(`Uptime: ${Math.floor(data.uptime / 1e3)}s`);
-          } catch {
-            console.log("Server is not running.");
-          }
-        }
-      })
-    }
-  });
-  const wrapCommand = defineCommand({
-    meta: { name: "wrap", description: "Register a tool" },
-    subCommands: {
-      cli: defineCommand({
-        meta: { name: "cli", description: "Wrap a CLI command" },
-        async run() {
-          const { wrapCli } = await requireServer();
-          await wrapCli();
-        }
-      }),
-      mcp: defineCommand({
-        meta: { name: "mcp", description: "Wrap an MCP server" },
-        async run() {
-          const { wrapMcp } = await requireServer();
-          await wrapMcp();
-        }
-      }),
-      script: defineCommand({
-        meta: { name: "script", description: "Wrap a script" },
-        async run() {
-          const { wrapScript } = await requireServer();
-          await wrapScript();
-        }
-      }),
-      import: defineCommand({
-        meta: { name: "import", description: "Import from claude_desktop_config.json" },
-        args: {
-          path: { type: "positional", description: "Path to config file", required: true }
-        },
-        async run({ args }) {
-          const { wrapImport } = await requireServer();
-          await wrapImport(args.path);
-        }
-      })
-    }
-  });
-  const unwrapCommand = defineCommand({
-    meta: { name: "unwrap", description: "Unregister a tool" },
-    args: {
-      name: { type: "positional", description: "Tool name", required: true }
-    },
-    async run({ args }) {
-      const { unwrapTool } = await requireServer();
-      await unwrapTool(args.name);
-    }
-  });
-  const main = defineCommand({
-    meta: {
-      name: "gigai",
-      version: VERSION,
-      description: "Bridge CLI tools to Claude across platforms"
-    },
-    subCommands: mode === "client" ? {
-      pair: pairCommand,
-      connect: connectCommand,
-      list: listCommand,
-      help: helpCommand,
-      status: statusCommand,
-      upload: uploadCommand,
-      download: downloadCommand,
-      version: versionCommand
-    } : {
-      server: serverCommand,
-      wrap: wrapCommand,
-      unwrap: unwrapCommand,
-      version: versionCommand,
-      pair: pairCommand,
-      connect: connectCommand,
-      list: listCommand,
-      status: statusCommand
-    }
-  });
-  runMain(main);
-}
+});
+runMain(main);