@schuttdev/gigai 0.1.0-beta.9 → 0.2.2

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   decodeJWTPayload
-} from "./chunk-4XUWD3DZ.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
@@ -51,8 +104,8 @@ function getOrgUUID() {
   if (process.env.GIGAI_ORG_UUID) {
     return process.env.GIGAI_ORG_UUID;
   }
-  const proxyUrl = process.env.ANTHROPIC_PROXY_URL ?? "";
-  const jwtMatch = proxyUrl.match(/\/([A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/);
+  const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY || "";
+  const jwtMatch = proxyUrl.match(/jwt_([^@]+)/);
   if (jwtMatch) {
     try {
       const payload = decodeJWTPayload(jwtMatch[1]);
@@ -62,18 +115,25 @@ function getOrgUUID() {
     } 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;
+      }
+    } catch {
+    }
+  }
   const apiKey = process.env.ANTHROPIC_API_KEY ?? "";
-  if (apiKey.includes("/")) {
-    const parts = apiKey.split("/");
-    const jwtPart = parts.find((p) => p.includes(".") && p.split(".").length === 3);
-    if (jwtPart) {
-      try {
-        const payload = decodeJWTPayload(jwtPart);
-        if (payload.organization_uuid) {
-          return payload.organization_uuid;
-        }
-      } catch {
+  if (apiKey.includes(".")) {
+    try {
+      const payload = decodeJWTPayload(apiKey);
+      if (payload.organization_uuid) {
+        return payload.organization_uuid;
       }
+    } catch {
     }
   }
   throw new Error(
@@ -82,6 +142,23 @@ function getOrgUUID() {
 }
 
 // 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 = {}) {
@@ -94,10 +171,15 @@ function createHttpClient(serverUrl, sessionToken) {
     if (!headers["Content-Type"] && init.body && typeof init.body === "string") {
       headers["Content-Type"] = "application/json";
     }
-    const res = await fetch(`${baseUrl}${path}`, {
+    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 {
@@ -124,11 +206,16 @@ function createHttpClient(serverUrl, sessionToken) {
       if (sessionToken) {
         headers["Authorization"] = `Bearer ${sessionToken}`;
       }
-      const res = await fetch(`${baseUrl}${path}`, {
+      const dispatcher = await ensureDispatcher();
+      const fetchOpts = {
         method: "POST",
         headers,
         body: formData
-      });
+      };
+      if (dispatcher) {
+        fetchOpts.dispatcher = dispatcher;
+      }
+      const res = await fetch(`${baseUrl}${path}`, fetchOpts);
       if (!res.ok) {
         let errorBody;
         try {
@@ -144,7 +231,12 @@ function createHttpClient(serverUrl, sessionToken) {
       if (sessionToken) {
         headers["Authorization"] = `Bearer ${sessionToken}`;
       }
-      const res = await fetch(`${baseUrl}${path}`, { headers });
+      const dispatcher = await ensureDispatcher();
+      const fetchOpts = { headers };
+      if (dispatcher) {
+        fetchOpts.dispatcher = dispatcher;
+      }
+      const res = await fetch(`${baseUrl}${path}`, fetchOpts);
       if (!res.ok) {
         throw new Error(`HTTP ${res.status}: ${res.statusText}`);
       }
@@ -153,31 +245,274 @@ function createHttpClient(serverUrl, sessionToken) {
   };
 }
 
+// src/version.ts
+var VERSION = "0.2.2";
+
 // 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) {
+      await checkAndUpdateServer(entry.server, entry.sessionToken);
+      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);
+  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"}`);
+      }
+    }
+  } 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 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 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
@@ -188,17 +523,17 @@ async function pair(code, serverUrl) {
     pairingCode: code,
     orgUuid
   });
-  await updateConfig({
-    server: serverUrl,
-    token: res.encryptedToken,
-    sessionToken: void 0,
-    sessionExpiresAt: void 0
-  });
-  console.log("Paired successfully!");
+  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;
@@ -208,7 +543,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;
@@ -218,9 +553,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;
@@ -240,13 +575,32 @@ async function execTool(http, name, args, timeout) {
   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 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]);
@@ -261,7 +615,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}`);
 }
 
@@ -302,26 +656,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",
@@ -331,23 +691,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);
+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;
     }
-  } else {
-    runCitty();
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exitCode = 1;
   }
 } else {
   runCitty();
@@ -365,8 +738,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}`);
     }
   });
@@ -395,8 +771,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({
@@ -425,7 +800,7 @@ function runCitty() {
   const versionCommand = defineCommand({
     meta: { name: "version", description: "Show version" },
     run() {
-      console.log("gigai v0.1.0");
+      console.log(`gigai v${VERSION}`);
     }
   });
   const serverCommand = defineCommand({
@@ -438,7 +813,7 @@ function runCitty() {
           dev: { type: "boolean", description: "Development mode (no HTTPS)" }
         },
         async run({ args }) {
-          const { startServer } = await import("./dist-CU5WVKG2.js");
+          const { startServer } = await import("./dist-U7NYIMA4.js");
           const extraArgs = [];
           if (args.config) extraArgs.push("--config", args.config);
           if (args.dev) extraArgs.push("--dev");
@@ -449,7 +824,7 @@ function runCitty() {
       init: defineCommand({
         meta: { name: "init", description: "Interactive setup wizard" },
         async run() {
-          const { runInit } = await import("./dist-CU5WVKG2.js");
+          const { runInit } = await import("./dist-U7NYIMA4.js");
           await runInit();
         }
       }),
@@ -459,10 +834,51 @@ function runCitty() {
           config: { type: "string", alias: "c", description: "Config file path" }
         },
         async run({ args }) {
-          const { generateServerPairingCode } = await import("./dist-CU5WVKG2.js");
+          const { generateServerPairingCode } = await import("./dist-U7NYIMA4.js");
           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 import("./dist-U7NYIMA4.js");
+          await installDaemon(args.config);
+        }
+      }),
+      uninstall: defineCommand({
+        meta: { name: "uninstall", description: "Remove background service" },
+        async run() {
+          const { uninstallDaemon } = await import("./dist-U7NYIMA4.js");
+          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() {
@@ -486,21 +902,21 @@ function runCitty() {
       cli: defineCommand({
         meta: { name: "cli", description: "Wrap a CLI command" },
         async run() {
-          const { wrapCli } = await import("./dist-CU5WVKG2.js");
+          const { wrapCli } = await import("./dist-U7NYIMA4.js");
           await wrapCli();
         }
       }),
       mcp: defineCommand({
         meta: { name: "mcp", description: "Wrap an MCP server" },
         async run() {
-          const { wrapMcp } = await import("./dist-CU5WVKG2.js");
+          const { wrapMcp } = await import("./dist-U7NYIMA4.js");
           await wrapMcp();
         }
       }),
       script: defineCommand({
         meta: { name: "script", description: "Wrap a script" },
         async run() {
-          const { wrapScript } = await import("./dist-CU5WVKG2.js");
+          const { wrapScript } = await import("./dist-U7NYIMA4.js");
           await wrapScript();
         }
       }),
@@ -510,7 +926,7 @@ function runCitty() {
           path: { type: "positional", description: "Path to config file", required: true }
         },
         async run({ args }) {
-          const { wrapImport } = await import("./dist-CU5WVKG2.js");
+          const { wrapImport } = await import("./dist-U7NYIMA4.js");
           await wrapImport(args.path);
         }
       })
@@ -522,14 +938,14 @@ function runCitty() {
       name: { type: "positional", description: "Tool name", required: true }
     },
     async run({ args }) {
-      const { unwrapTool } = await import("./dist-CU5WVKG2.js");
+      const { unwrapTool } = await import("./dist-U7NYIMA4.js");
       await unwrapTool(args.name);
     }
   });
   const main = defineCommand({
     meta: {
       name: "gigai",
-      version: "0.1.0",
+      version: VERSION,
       description: "Bridge CLI tools to Claude across platforms"
     },
     subCommands: mode === "client" ? {