@schuttdev/kon 0.2.6

package/dist/index.js

@@ -0,0 +1,908 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand, runMain } from "citty";
+
+// ../cli/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) {
+  try {
+    const u = new URL(url);
+    return u.hostname.toLowerCase();
+  } 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");
+  }
+  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);
+}
+
+// ../cli/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;
+      }
+    } 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(".")) {
+    try {
+      const payload = decodeJWTPayload(apiKey);
+      if (payload.organization_uuid) {
+        return payload.organization_uuid;
+      }
+    } catch {
+    }
+  }
+  throw new Error(
+    "Cannot determine organization UUID. Set GIGAI_ORG_UUID environment variable."
+  );
+}
+
+// ../cli/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 {
+      }
+      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}`;
+      }
+      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 {
+          errorBody = await res.json();
+        } catch {
+        }
+        throw new Error(errorBody?.error?.message ?? `HTTP ${res.status}`);
+      }
+      return res.json();
+    },
+    async getRaw(path) {
+      const headers = {};
+      if (sessionToken) {
+        headers["Authorization"] = `Bearer ${sessionToken}`;
+      }
+      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}`);
+      }
+      return res;
+    }
+  };
+}
+
+// ../cli/src/version.ts
+var VERSION = "0.2.6";
+
+// ../cli/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"}`);
+      }
+    }
+  } 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;
+}
+
+// ../cli/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/kon 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]);
+}
+
+// ../cli/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).");
+  }
+}
+
+// ../cli/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)}`);
+}
+
+// ../cli/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;
+  }
+}
+
+// ../cli/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}`);
+}
+
+// ../cli/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");
+      }
+    }
+  }
+  return `Servers:
+${lines.join("\n")}`;
+}
+
+// src/index.ts
+var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
+  "pair",
+  "connect",
+  "list",
+  "help",
+  "status",
+  "upload",
+  "download",
+  "version",
+  "--help",
+  "-h"
+]);
+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();
+}
+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} (kon)`);
+    }
+  });
+  const main = defineCommand({
+    meta: {
+      name: "gigai",
+      version: VERSION,
+      description: "gigai client \u2014 bridge CLI tools to Claude"
+    },
+    subCommands: {
+      pair: pairCommand,
+      connect: connectCommand,
+      list: listCommand,
+      help: helpCommand,
+      status: statusCommand,
+      upload: uploadCommand,
+      download: downloadCommand,
+      version: versionCommand
+    }
+  });
+  runMain(main);
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@schuttdev/kon",
+  "version": "0.2.6",
+  "type": "module",
+  "description": "Lightweight gigai client for Claude code execution",
+  "bin": {
+    "gigai": "dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "zod": "^3.22.0",
+    "undici": "^6.0.0"
+  },
+  "devDependencies": {
+    "@gigai/shared": "*",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  }
+}