@schuttdev/gigai 0.2.7 → 0.2.9

package/dist/{dist-MGLETZTT.js → dist-YWMCMOTP.js}

@@ -239,7 +239,7 @@ var ScriptToolConfigSchema = z.object({
 var BuiltinToolConfigSchema = z.object({
   type: z.literal("builtin"),
   name: z.string(),
-  builtin: z.enum(["filesystem", "shell"]),
+  builtin: z.enum(["filesystem", "shell", "read", "write", "edit", "glob", "grep", "bash"]),
   description: z.string(),
   config: z.record(z.unknown()).optional()
 });
@@ -280,24 +280,29 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { readFileSync } from "fs";
 import { resolve } from "path";
-import { readFile as fsReadFile, readdir } from "fs/promises";
+import {
+  readFile as fsReadFile,
+  writeFile as fsWriteFile,
+  readdir
+} from "fs/promises";
 import { resolve as resolve2, relative, join } from "path";
 import { realpath } from "fs/promises";
 import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { writeFile, readFile, unlink, mkdir } from "fs/promises";
 import { join as join2 } from "path";
 import { tmpdir } from "os";
 import { nanoid as nanoid3 } from "nanoid";
-import { execFile, spawn as spawn3 } from "child_process";
+import { execFile, spawn as spawn4 } from "child_process";
 import { promisify } from "util";
 import { readFile as readFile2 } from "fs/promises";
 import { resolve as resolve3 } from "path";
-import { spawn as spawn4 } from "child_process";
 import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { input, select, checkbox, confirm } from "@inquirer/prompts";
 import { writeFile as writeFile2 } from "fs/promises";
 import { resolve as resolve4 } from "path";
-import { execFile as execFile2, spawn as spawn6 } from "child_process";
+import { execFile as execFile2, spawn as spawn7 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { input as input2 } from "@inquirer/prompts";
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
@@ -841,6 +846,26 @@ async function toolRoutes(server) {
   server.get("/tools", async () => {
     return { tools: server.registry.list() };
   });
+  server.get("/tools/search", async (request) => {
+    const query = request.query.q?.toLowerCase().trim();
+    if (!query) {
+      return { tools: server.registry.list() };
+    }
+    const all = server.registry.list();
+    const keywords = query.split(/\s+/);
+    const scored = all.map((tool) => {
+      const text = `${tool.name} ${tool.description}`.toLowerCase();
+      let score = 0;
+      for (const kw of keywords) {
+        if (tool.name.toLowerCase() === kw) score += 10;
+        else if (tool.name.toLowerCase().includes(kw)) score += 5;
+        if (tool.description.toLowerCase().includes(kw)) score += 2;
+      }
+      return { tool, score };
+    });
+    const matches = scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, 10).map((s) => s.tool);
+    return { tools: matches };
+  });
   server.get("/tools/:name", async (request) => {
     const { name } = request.params;
     const detail = server.registry.getDetail(name);
@@ -864,6 +889,8 @@ async function toolRoutes(server) {
     return { tools: mcpTools };
   });
 }
+var MAX_OUTPUT_SIZE2 = 10 * 1024 * 1024;
+var MAX_READ_SIZE = 2 * 1024 * 1024;
 async function validatePath(targetPath, allowedPaths) {
   const resolved = resolve2(targetPath);
   let real;
@@ -921,6 +948,250 @@ async function searchFilesSafe(path, pattern, allowedPaths) {
   await walk(safePath);
   return results;
 }
+async function readBuiltin(args, allowedPaths) {
+  const filePath = args[0];
+  if (!filePath) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: read <file> [offset] [limit]");
+  }
+  const safePath = await validatePath(filePath, allowedPaths);
+  const content = await fsReadFile(safePath, "utf8");
+  if (content.length > MAX_READ_SIZE) {
+    throw new GigaiError(
+      ErrorCode.VALIDATION_ERROR,
+      `File too large (${(content.length / 1024 / 1024).toFixed(1)}MB). Max: ${MAX_READ_SIZE / 1024 / 1024}MB. Use offset/limit.`
+    );
+  }
+  const offset = args[1] ? parseInt(args[1], 10) : 0;
+  const limit = args[2] ? parseInt(args[2], 10) : 0;
+  if (offset || limit) {
+    const lines = content.split("\n");
+    const start = Math.max(0, offset);
+    const end = limit ? start + limit : lines.length;
+    const sliced = lines.slice(start, end);
+    return { stdout: sliced.join("\n"), stderr: "", exitCode: 0 };
+  }
+  return { stdout: content, stderr: "", exitCode: 0 };
+}
+async function writeBuiltin(args, allowedPaths) {
+  const filePath = args[0];
+  const content = args[1];
+  if (!filePath || content === void 0) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: write <file> <content>");
+  }
+  const safePath = await validatePath(filePath, allowedPaths);
+  const { mkdir: mkdir2 } = await import("fs/promises");
+  const { dirname } = await import("path");
+  await mkdir2(dirname(safePath), { recursive: true });
+  await fsWriteFile(safePath, content, "utf8");
+  return { stdout: `Written: ${safePath}`, stderr: "", exitCode: 0 };
+}
+async function editBuiltin(args, allowedPaths) {
+  const filePath = args[0];
+  const oldStr = args[1];
+  const newStr = args[2];
+  const replaceAll = args.includes("--all");
+  if (!filePath || oldStr === void 0 || newStr === void 0) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: edit <file> <old_string> <new_string> [--all]");
+  }
+  const safePath = await validatePath(filePath, allowedPaths);
+  const content = await fsReadFile(safePath, "utf8");
+  if (!content.includes(oldStr)) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "old_string not found in file");
+  }
+  if (!replaceAll) {
+    const firstIdx = content.indexOf(oldStr);
+    const secondIdx = content.indexOf(oldStr, firstIdx + 1);
+    if (secondIdx !== -1) {
+      throw new GigaiError(
+        ErrorCode.VALIDATION_ERROR,
+        "old_string matches multiple locations. Use --all to replace all, or provide more context to make it unique."
+      );
+    }
+  }
+  const updated = replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
+  await fsWriteFile(safePath, updated, "utf8");
+  const count = replaceAll ? content.split(oldStr).length - 1 : 1;
+  return { stdout: `Replaced ${count} occurrence(s) in ${safePath}`, stderr: "", exitCode: 0 };
+}
+async function globBuiltin(args, allowedPaths) {
+  const pattern = args[0];
+  if (!pattern) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: glob <pattern> [path]");
+  }
+  const searchPath = args[1] ?? ".";
+  const safePath = await validatePath(searchPath, allowedPaths);
+  const results = [];
+  const globRegex = globToRegex(pattern);
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      const relPath = relative(safePath, fullPath);
+      if (globRegex.test(relPath) || globRegex.test(entry.name)) {
+        results.push(relPath);
+      }
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        await walk(fullPath);
+      }
+      if (results.length >= 1e3) return;
+    }
+  }
+  await walk(safePath);
+  return { stdout: results.join("\n"), stderr: "", exitCode: 0 };
+}
+async function grepBuiltin(args, allowedPaths) {
+  if (args.length === 0) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: grep <pattern> [path] [--glob <filter>] [-i] [-n] [-C <num>]");
+  }
+  const positional = [];
+  const flags = [];
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--glob" && args[i + 1]) {
+      flags.push("--glob", args[i + 1]);
+      i += 2;
+    } else if (arg === "--type" && args[i + 1]) {
+      flags.push("--type", args[i + 1]);
+      i += 2;
+    } else if (arg === "-C" && args[i + 1]) {
+      flags.push("-C", args[i + 1]);
+      i += 2;
+    } else if (arg === "-i" || arg === "-n" || arg === "-l") {
+      flags.push(arg);
+      i++;
+    } else {
+      positional.push(arg);
+      i++;
+    }
+  }
+  const pattern = positional[0];
+  if (!pattern) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "No search pattern provided");
+  }
+  const searchPath = positional[1] ?? ".";
+  const safePath = await validatePath(searchPath, allowedPaths);
+  try {
+    return await spawnGrep("rg", [pattern, safePath, "-n", ...flags]);
+  } catch {
+    try {
+      return await spawnGrep("grep", ["-rn", ...flags, pattern, safePath]);
+    } catch {
+      return jsGrep(pattern, safePath);
+    }
+  }
+}
+function spawnGrep(cmd, args) {
+  return new Promise((resolve7, reject) => {
+    const child = spawn2(cmd, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let totalSize = 0;
+    child.stdout.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize <= MAX_OUTPUT_SIZE2) stdoutChunks.push(chunk);
+      else child.kill("SIGTERM");
+    });
+    child.stderr.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize <= MAX_OUTPUT_SIZE2) stderrChunks.push(chunk);
+    });
+    child.on("error", () => reject(new Error(`${cmd} not available`)));
+    child.on("close", (exitCode) => {
+      resolve7({
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+        exitCode: exitCode ?? 1
+      });
+    });
+  });
+}
+async function jsGrep(pattern, searchPath) {
+  let regex;
+  try {
+    regex = new RegExp(pattern);
+  } catch {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, `Invalid pattern: ${pattern}`);
+  }
+  const results = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (results.length >= 500) return;
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+          await walk(fullPath);
+        }
+      } else {
+        try {
+          const content = await fsReadFile(fullPath, "utf8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              results.push(`${relative(searchPath, fullPath)}:${i + 1}:${lines[i]}`);
+              if (results.length >= 500) return;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  await walk(searchPath);
+  return {
+    stdout: results.join("\n"),
+    stderr: results.length >= 500 ? "Results truncated at 500 matches" : "",
+    exitCode: results.length > 0 ? 0 : 1
+  };
+}
+function globToRegex(pattern) {
+  let regex = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        regex += ".*";
+        i += 2;
+        if (pattern[i] === "/") i++;
+      } else {
+        regex += "[^/]*";
+        i++;
+      }
+    } else if (c === "?") {
+      regex += "[^/]";
+      i++;
+    } else if (c === "{") {
+      const end = pattern.indexOf("}", i);
+      if (end !== -1) {
+        const options = pattern.slice(i + 1, end).split(",");
+        regex += `(?:${options.map(escapeRegex).join("|")})`;
+        i = end + 1;
+      } else {
+        regex += escapeRegex(c);
+        i++;
+      }
+    } else {
+      regex += escapeRegex(c);
+      i++;
+    }
+  }
+  return new RegExp(regex);
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 var SHELL_INTERPRETERS = /* @__PURE__ */ new Set([
   "sh",
   "bash",
@@ -936,7 +1207,7 @@ var SHELL_INTERPRETERS = /* @__PURE__ */ new Set([
   "strace",
   "ltrace"
 ]);
-var MAX_OUTPUT_SIZE2 = 10 * 1024 * 1024;
+var MAX_OUTPUT_SIZE3 = 10 * 1024 * 1024;
 async function execCommandSafe(command, args, config) {
   if (!config.allowlist.includes(command)) {
     throw new GigaiError(
@@ -959,7 +1230,7 @@ async function execCommandSafe(command, args, config) {
     }
   }
   return new Promise((resolve7, reject) => {
-    const child = spawn2(command, args, {
+    const child = spawn3(command, args, {
       shell: false,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -968,12 +1239,12 @@ async function execCommandSafe(command, args, config) {
     let totalSize = 0;
     child.stdout.on("data", (chunk) => {
       totalSize += chunk.length;
-      if (totalSize <= MAX_OUTPUT_SIZE2) stdoutChunks.push(chunk);
+      if (totalSize <= MAX_OUTPUT_SIZE3) stdoutChunks.push(chunk);
       else child.kill("SIGTERM");
     });
     child.stderr.on("data", (chunk) => {
       totalSize += chunk.length;
-      if (totalSize <= MAX_OUTPUT_SIZE2) stderrChunks.push(chunk);
+      if (totalSize <= MAX_OUTPUT_SIZE3) stderrChunks.push(chunk);
       else child.kill("SIGTERM");
     });
     child.on("error", (err) => {
@@ -1047,6 +1318,7 @@ async function execRoutes(server) {
 async function handleBuiltin(config, args) {
   const builtinConfig = config.config ?? {};
   switch (config.builtin) {
+    // Legacy combined filesystem tool
     case "filesystem": {
       const allowedPaths = builtinConfig.allowedPaths ?? ["."];
       const subcommand = args[0];
@@ -1062,6 +1334,7 @@ async function handleBuiltin(config, args) {
           throw new GigaiError(ErrorCode.VALIDATION_ERROR, `Unknown filesystem subcommand: ${subcommand}. Use: read, list, search`);
       }
     }
+    // Legacy shell tool
     case "shell": {
       const allowlist = builtinConfig.allowlist ?? [];
       const allowSudo = builtinConfig.allowSudo ?? false;
@@ -1072,6 +1345,37 @@ async function handleBuiltin(config, args) {
       const result = await execCommandSafe(command, args.slice(1), { allowlist, allowSudo });
       return { ...result, durationMs: 0 };
     }
+    // --- New builtins ---
+    case "read": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await readBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "write": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await writeBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "edit": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await editBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "glob": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await globBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "grep": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await grepBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "bash": {
+      const allowlist = builtinConfig.allowlist ?? [];
+      const allowSudo = builtinConfig.allowSudo ?? false;
+      const command = args[0];
+      if (!command) {
+        throw new GigaiError(ErrorCode.VALIDATION_ERROR, "No command specified");
+      }
+      const result = await execCommandSafe(command, args.slice(1), { allowlist, allowSudo });
+      return { ...result, durationMs: 0 };
+    }
     default:
       throw new GigaiError(ErrorCode.VALIDATION_ERROR, `Unknown builtin: ${config.builtin}`);
   }
@@ -1147,7 +1451,7 @@ async function adminRoutes(server) {
     }
     setTimeout(async () => {
       server.log.info("Restarting server after update...");
-      const args = ["server", "start"];
+      const args = ["start"];
       const configIdx = process.argv.indexOf("--config");
       if (configIdx !== -1 && process.argv[configIdx + 1]) {
         args.push("--config", process.argv[configIdx + 1]);
@@ -1160,7 +1464,7 @@ async function adminRoutes(server) {
         args.push("--dev");
       }
       await server.close();
-      const child = spawn3("gigai", args, {
+      const child = spawn4("gigai", args, {
         detached: true,
         stdio: "ignore",
         cwd: process.cwd()
@@ -1228,7 +1532,7 @@ async function loadConfig(path) {
 }
 function runCommand(command, args) {
   return new Promise((resolve7, reject) => {
-    const child = spawn4(command, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn5(command, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     child.stdout.on("data", (chunk) => chunks.push(chunk));
     child.on("error", reject);
@@ -1269,7 +1573,7 @@ async function disableFunnel(port) {
   await runCommand("tailscale", ["funnel", "--bg", "off", `${port}`]);
 }
 function runTunnel(tunnelName, localPort) {
-  const child = spawn5("cloudflared", [
+  const child = spawn6("cloudflared", [
     "tunnel",
     "--url",
     `http://localhost:${localPort}`,
@@ -1472,7 +1776,7 @@ async function runInit() {
       serverUrl = await ensureTailscaleFunnel(port);
     } catch (e) {
       console.error(`  ${e.message}`);
-      console.log("  You can enable Funnel later and run 'gigai server start' manually.\n");
+      console.log("  You can enable Funnel later and run 'gigai start' manually.\n");
     }
   } else if (httpsProvider === "cloudflare" && httpsConfig && "domain" in httpsConfig && httpsConfig.domain) {
     serverUrl = `https://${httpsConfig.domain}`;
@@ -1485,9 +1789,9 @@ async function runInit() {
     });
   }
   console.log("\n  Starting server...");
-  const serverArgs = ["server", "start", "--config", configPath];
+  const serverArgs = ["start", "--config", configPath];
   if (!httpsConfig) serverArgs.push("--dev");
-  const child = spawn6("gigai", serverArgs, {
+  const child = spawn7("gigai", serverArgs, {
     detached: true,
     stdio: "ignore",
     cwd: resolve4(".")
@@ -1518,7 +1822,7 @@ async function runInit() {
   }
   if (!code) {
     console.log("\n  Server is starting but not ready yet.");
-    console.log("  Run 'gigai server pair' once it's up to get a pairing code.\n");
+    console.log("  Run 'gigai pair' once it's up to get a pairing code.\n");
     return;
   }
   console.log(`
@@ -1536,7 +1840,7 @@ async function runInit() {
   console.log(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
   console.log(`
   Pairing code expires in ${config.auth.pairingTtlSeconds / 60} minutes.`);
-  console.log(`  Run 'gigai server pair' to generate a new one.
+  console.log(`  Run 'gigai pair' to generate a new one.
 `);
 }
 async function loadConfigFile(path) {
@@ -1663,7 +1967,7 @@ Pairing code: ${data.code}`);
     console.log(`Expires in ${data.expiresIn / 60} minutes.`);
   } catch (e) {
     if (e.message.includes("fetch failed") || e.message.includes("ECONNREFUSED")) {
-      console.error("Server is not running. Start it with: gigai server start");
+      console.error("Server is not running. Start it with: gigai start");
     } else {
       console.error(`Error: ${e.message}`);
     }
@@ -1696,7 +2000,6 @@ function getLaunchdPlist(configPath) {
   <array>
     <string>${nodeBin}</string>
     <string>${bin}</string>
-    <string>server</string>
     <string>start</string>
     <string>--config</string>
     <string>${configPath}</string>
@@ -1723,7 +2026,7 @@ After=network.target
 
 [Service]
 Type=simple
-ExecStart=${bin} server start --config ${configPath}
+ExecStart=${bin} start --config ${configPath}
 Restart=always
 RestartSec=5
 WorkingDirectory=${homedir()}
@@ -1766,7 +2069,7 @@ async function installDaemon(configPath) {
     console.log(`  Remove: systemctl --user disable gigai`);
   } else {
     console.log("  Persistent daemon not supported on this platform.");
-    console.log("  Run 'gigai server start' manually.");
+    console.log("  Run 'gigai start' manually.");
   }
 }
 async function uninstallDaemon() {
@@ -1804,7 +2107,7 @@ async function stopServer() {
   const { execFileSync } = await import("child_process");
   let pids = [];
   try {
-    const out = execFileSync("pgrep", ["-f", "gigai server start"], { encoding: "utf8" });
+    const out = execFileSync("pgrep", ["-f", "gigai start"], { encoding: "utf8" });
     pids = out.trim().split("\n").map(Number).filter((pid) => pid && pid !== process.pid);
   } catch {
   }

package/dist/index.js

@@ -4,109 +4,104 @@
 import { defineCommand, runMain } from "citty";
 
 // src/version.ts
-var VERSION = "0.2.7";
+var VERSION = "0.2.9";
 
 // src/index.ts
 async function requireServer() {
   try {
-    return await import("./dist-MGLETZTT.js");
+    return await import("./dist-YWMCMOTP.js");
   } catch {
     console.error("Server dependencies not installed.");
     console.error("Run: npm install -g @schuttdev/gigai");
     process.exit(1);
   }
 }
-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();
-      }
-    }),
-    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.");
-        }
+var initCommand = defineCommand({
+  meta: { name: "init", description: "Interactive setup wizard" },
+  async run() {
+    const { runInit } = await requireServer();
+    await runInit();
+  }
+});
+var startCommand = 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();
+  }
+});
+var stopCommand = 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 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}`);
       }
-    })
+    }
+  }
+});
+var statusCommand = 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.");
+    }
+  }
+});
+var pairCommand = 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);
+  }
+});
+var installCommand = 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);
+  }
+});
+var uninstallCommand = defineCommand({
+  meta: { name: "uninstall", description: "Remove background service" },
+  async run() {
+    const { uninstallDaemon } = await requireServer();
+    await uninstallDaemon();
   }
 });
 var wrapCommand = defineCommand({
@@ -165,10 +160,16 @@ var main = defineCommand({
   meta: {
     name: "gigai",
     version: VERSION,
-    description: "gigai server \u2014 bridge CLI tools to Claude"
+    description: "gigai \u2014 bridge CLI tools to Claude"
   },
   subCommands: {
-    server: serverCommand,
+    init: initCommand,
+    start: startCommand,
+    stop: stopCommand,
+    status: statusCommand,
+    pair: pairCommand,
+    install: installCommand,
+    uninstall: uninstallCommand,
     wrap: wrapCommand,
     unwrap: unwrapCommand,
     version: versionCommand

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schuttdev/gigai",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "type": "module",
   "bin": {
     "gigai": "dist/index.js"