cursor-kit-cli 1.6.0 → 1.7.0-beta.1

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { defineCommand as defineCommand7, runMain } from "citty";
+import { defineCommand as defineCommand9, runMain } from "citty";
 import { createRequire } from "module";
 
 // src/utils/branding.ts
@@ -24,6 +24,9 @@ function printBanner() {
 function printSuccess(message) {
   console.log(pc.green("\u2713") + pc.dim(" ") + message);
 }
+function printError(message) {
+  console.log(pc.red("\u2717") + pc.dim(" ") + message);
+}
 function printInfo(message) {
   console.log(pc.cyan("\u2139") + pc.dim(" ") + message);
 }
@@ -2319,7 +2322,7 @@ function getStorageLocationLabel(location) {
 function isHomeBinInPath() {
   const pathEnv = process.env.PATH ?? "";
   const homeBin = getHomeBinDir();
-  return pathEnv.split(":").some((p9) => p9 === homeBin || p9 === "~/bin" || p9 === "$HOME/bin");
+  return pathEnv.split(":").some((p11) => p11 === homeBin || p11 === "~/bin" || p11 === "$HOME/bin");
 }
 function getPathSetupInstructions() {
   const shell = process.env.SHELL ?? "/bin/zsh";
@@ -2885,10 +2888,580 @@ var instanceCommand = defineCommand6({
   }
 });
 
+// src/commands/share.ts
+import { defineCommand as defineCommand7 } from "citty";
+import * as p9 from "@clack/prompts";
+import pc9 from "picocolors";
+import { createServer } from "http";
+import { networkInterfaces } from "os";
+import archiver from "archiver";
+var DEFAULT_PORT = 8080;
+var MAX_PORT_RETRIES = 10;
+var METADATA_FILENAME = ".cursor-kit-share.json";
+function getLocalIp() {
+  const nets = networkInterfaces();
+  for (const name of Object.keys(nets)) {
+    const netList = nets[name];
+    if (!netList) continue;
+    for (const net of netList) {
+      if (net.family === "IPv4" && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+  return "127.0.0.1";
+}
+function detectAvailableConfigs(cwd) {
+  const configs = [];
+  const cursorDir = getCursorDir(cwd);
+  if (dirExists(cursorDir)) {
+    configs.push({
+      type: "cursor",
+      label: "Cursor",
+      directory: ".cursor",
+      path: cursorDir
+    });
+  }
+  const agentDir = getAgentDir(cwd);
+  if (dirExists(agentDir)) {
+    configs.push({
+      type: "google-antigravity",
+      label: "Google AntiGravity",
+      directory: ".agent",
+      path: agentDir
+    });
+  }
+  const githubDir = getGitHubDir(cwd);
+  const copilotInstructionsPath = getCopilotInstructionsPath(cwd);
+  const copilotInstructionsDir = getCopilotInstructionsDir(cwd);
+  if (fileExists(copilotInstructionsPath) || dirExists(copilotInstructionsDir)) {
+    configs.push({
+      type: "github-copilot",
+      label: "GitHub Copilot",
+      directory: ".github",
+      path: githubDir
+    });
+  }
+  return configs;
+}
+function tryListen(server, port) {
+  return new Promise((resolve2, reject) => {
+    const handleError = (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} is already in use`));
+      } else {
+        reject(err);
+      }
+    };
+    server.once("error", handleError);
+    server.listen(port, () => {
+      server.removeListener("error", handleError);
+      resolve2(port);
+    });
+  });
+}
+async function findAvailablePort(server, startPort) {
+  for (let i = 0; i < MAX_PORT_RETRIES; i++) {
+    const port = startPort + i;
+    try {
+      return await tryListen(server, port);
+    } catch {
+      if (i === MAX_PORT_RETRIES - 1) {
+        throw new Error(`Could not find an available port after ${MAX_PORT_RETRIES} attempts`);
+      }
+    }
+  }
+  throw new Error("Unexpected error finding available port");
+}
+function createConfigZipStream(selectedConfigs) {
+  const archive = archiver("zip", {
+    zlib: { level: 6 }
+  });
+  archive.on("warning", (err) => {
+    if (err.code !== "ENOENT") {
+      console.warn(pc9.yellow(`Warning: ${err.message}`));
+    }
+  });
+  archive.on("error", (err) => {
+    throw err;
+  });
+  const metadata = {
+    version: 1,
+    configs: selectedConfigs.map((c) => c.type)
+  };
+  archive.append(JSON.stringify(metadata, null, 2), { name: METADATA_FILENAME });
+  for (const config of selectedConfigs) {
+    archive.directory(config.path, config.directory);
+  }
+  archive.finalize();
+  return archive;
+}
+function handleRequest(req, res, selectedConfigs, onTransferStart, onTransferComplete, onTransferError) {
+  if (req.method !== "GET" || req.url !== "/") {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
+    return;
+  }
+  onTransferStart();
+  res.writeHead(200, {
+    "Content-Type": "application/zip",
+    "Content-Disposition": 'attachment; filename="cursor-kit-configs.zip"',
+    "Transfer-Encoding": "chunked"
+  });
+  const archive = createConfigZipStream(selectedConfigs);
+  res.on("finish", () => {
+    onTransferComplete();
+  });
+  res.on("close", () => {
+    if (!res.writableFinished) {
+      onTransferError(new Error("Client disconnected before transfer completed"));
+    }
+  });
+  archive.on("error", (err) => {
+    onTransferError(err);
+    res.destroy();
+  });
+  archive.pipe(res);
+}
+var shareCommand = defineCommand7({
+  meta: {
+    name: "share",
+    description: "Share AI IDE configs (.cursor, .agent, .github) over LAN via HTTP"
+  },
+  args: {
+    port: {
+      type: "string",
+      alias: "p",
+      description: "Port to use for the HTTP server",
+      default: String(DEFAULT_PORT)
+    }
+  },
+  async run({ args }) {
+    const cwd = process.cwd();
+    const requestedPort = Number.parseInt(args.port, 10);
+    if (Number.isNaN(requestedPort) || requestedPort < 1 || requestedPort > 65535) {
+      p9.cancel("Invalid port number. Please specify a port between 1 and 65535.");
+      process.exit(1);
+    }
+    p9.intro(pc9.bgCyan(pc9.black(" cursor-kit share ")));
+    const availableConfigs = detectAvailableConfigs(cwd);
+    if (availableConfigs.length === 0) {
+      console.log();
+      printError("No AI IDE configs found in the current directory.");
+      printInfo("Run 'cursor-kit init' first to create configs for your AI IDE.");
+      console.log();
+      p9.cancel("Nothing to share");
+      process.exit(1);
+    }
+    let selectedConfigs;
+    if (availableConfigs.length === 1) {
+      selectedConfigs = availableConfigs;
+      printInfo(`Found: ${highlight(availableConfigs[0].label)} (${availableConfigs[0].directory})`);
+    } else {
+      const selection = await p9.multiselect({
+        message: "Which AI IDE configs do you want to share?",
+        options: availableConfigs.map((config) => ({
+          value: config.type,
+          label: config.label,
+          hint: config.directory
+        })),
+        required: true
+      });
+      if (p9.isCancel(selection)) {
+        p9.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      selectedConfigs = availableConfigs.filter(
+        (c) => selection.includes(c.type)
+      );
+    }
+    console.log();
+    const s = p9.spinner();
+    s.start("Starting HTTP server...");
+    let server = null;
+    let transferInProgress = false;
+    const cleanup = () => {
+      if (server) {
+        server.close();
+        server = null;
+      }
+    };
+    process.on("SIGINT", () => {
+      console.log();
+      if (transferInProgress) {
+        printError("Transfer interrupted");
+      } else {
+        printInfo("Server stopped");
+      }
+      cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(0);
+    });
+    try {
+      server = createServer((req, res) => {
+        handleRequest(
+          req,
+          res,
+          selectedConfigs,
+          () => {
+            transferInProgress = true;
+            console.log();
+            printInfo("Connection established, transferring files...");
+          },
+          () => {
+            transferInProgress = false;
+            console.log();
+            printSuccess("Transfer complete!");
+            printInfo("Server will shut down automatically.");
+            cleanup();
+            process.exit(0);
+          },
+          (err) => {
+            transferInProgress = false;
+            printError(`Transfer failed: ${err.message}`);
+          }
+        );
+      });
+      const actualPort = await findAvailablePort(server, requestedPort);
+      const localIp = getLocalIp();
+      s.stop("HTTP server started");
+      console.log();
+      printDivider();
+      console.log();
+      printInfo("Sharing configs:");
+      for (const config of selectedConfigs) {
+        console.log(pc9.dim(`   \u2514\u2500 ${pc9.green("\u25CF")} ${config.label} (${config.directory})`));
+      }
+      console.log();
+      printInfo(`Local IP: ${highlight(localIp)}`);
+      printInfo(`Port: ${highlight(String(actualPort))}`);
+      console.log();
+      printDivider();
+      console.log();
+      console.log(pc9.bold("  Run this command on the receiving machine:"));
+      console.log();
+      console.log(
+        `  ${pc9.cyan("$")} ${pc9.bold(pc9.green(`cursor-kit receive http://${localIp}:${actualPort}`))}`
+      );
+      console.log();
+      printDivider();
+      console.log();
+      printInfo("Waiting for connection... (Press Ctrl+C to cancel)");
+    } catch (error) {
+      s.stop("Failed to start server");
+      cleanup();
+      p9.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/receive.ts
+import { defineCommand as defineCommand8 } from "citty";
+import * as p10 from "@clack/prompts";
+import pc10 from "picocolors";
+import { get as httpGet } from "http";
+import { createWriteStream, createReadStream } from "fs";
+import { pipeline } from "stream/promises";
+import { PassThrough } from "stream";
+import unzipper from "unzipper";
+import { join as join11 } from "path";
+import { tmpdir } from "os";
+import { randomUUID } from "crypto";
+var METADATA_FILENAME2 = ".cursor-kit-share.json";
+function isValidUrl(urlString) {
+  try {
+    const url = new URL(urlString);
+    return url.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+function getConfigInfo(type, cwd) {
+  switch (type) {
+    case "cursor":
+      return {
+        type,
+        label: "Cursor",
+        directory: ".cursor",
+        targetPath: getCursorDir(cwd),
+        hasConflict: dirExists(getCursorDir(cwd))
+      };
+    case "google-antigravity":
+      return {
+        type,
+        label: "Google AntiGravity",
+        directory: ".agent",
+        targetPath: getAgentDir(cwd),
+        hasConflict: dirExists(getAgentDir(cwd))
+      };
+    case "github-copilot":
+      return {
+        type,
+        label: "GitHub Copilot",
+        directory: ".github",
+        targetPath: getGitHubDir(cwd),
+        hasConflict: dirExists(getGitHubDir(cwd))
+      };
+  }
+}
+async function downloadToTemp(url) {
+  const tempPath = join11(tmpdir(), `cursor-kit-receive-${randomUUID()}.zip`);
+  return new Promise((resolve2, reject) => {
+    const request = httpGet(url, (response) => {
+      if (response.statusCode !== 200) {
+        reject(new Error(`Server returned status ${response.statusCode}`));
+        return;
+      }
+      const writeStream = createWriteStream(tempPath);
+      const passThrough = new PassThrough();
+      let size = 0;
+      passThrough.on("data", (chunk) => {
+        size += chunk.length;
+      });
+      response.pipe(passThrough).pipe(writeStream);
+      writeStream.on("finish", () => {
+        resolve2({ tempPath, size });
+      });
+      writeStream.on("error", (err) => {
+        reject(err);
+      });
+      response.on("error", (err) => {
+        reject(err);
+      });
+    });
+    request.on("error", reject);
+    request.on("timeout", () => {
+      request.destroy();
+      reject(new Error("Connection timed out"));
+    });
+    request.setTimeout(3e4);
+  });
+}
+async function readMetadataFromZip(zipPath) {
+  return new Promise((resolve2) => {
+    const readStream = createReadStream(zipPath);
+    const unzipStream = readStream.pipe(unzipper.Parse());
+    let found = false;
+    unzipStream.on("entry", async (entry) => {
+      if (entry.path === METADATA_FILENAME2 && !found) {
+        found = true;
+        const chunks = [];
+        entry.on("data", (chunk) => chunks.push(chunk));
+        entry.on("end", () => {
+          try {
+            const content = Buffer.concat(chunks).toString("utf-8");
+            const metadata = JSON.parse(content);
+            resolve2(metadata);
+          } catch {
+            resolve2(null);
+          }
+        });
+      } else {
+        entry.autodrain();
+      }
+    });
+    unzipStream.on("close", () => {
+      if (!found) {
+        resolve2(null);
+      }
+    });
+    unzipStream.on("error", () => {
+      resolve2(null);
+    });
+  });
+}
+async function extractWithStrategy(zipPath, cwd, configs, strategy) {
+  if (strategy === "overwrite") {
+    for (const config of configs) {
+      if (config.hasConflict) {
+        removeFile(config.targetPath);
+      }
+    }
+  }
+  const configDirs = new Set(configs.map((c) => c.directory));
+  return new Promise((resolve2, reject) => {
+    const readStream = createReadStream(zipPath);
+    const unzipStream = readStream.pipe(unzipper.Parse());
+    const extractPromises = [];
+    unzipStream.on("entry", (entry) => {
+      const entryPath = entry.path;
+      if (entryPath === METADATA_FILENAME2) {
+        entry.autodrain();
+        return;
+      }
+      const topLevelDir = entryPath.split("/")[0];
+      if (!configDirs.has(topLevelDir)) {
+        entry.autodrain();
+        return;
+      }
+      const targetPath = join11(cwd, entryPath);
+      if (entry.type === "Directory") {
+        ensureDir(targetPath);
+        entry.autodrain();
+        return;
+      }
+      if (strategy === "merge" && fileExists(targetPath)) {
+        entry.autodrain();
+        return;
+      }
+      ensureDir(join11(targetPath, ".."));
+      const writeStream = createWriteStream(targetPath);
+      const extractPromise = pipeline(entry, writeStream);
+      extractPromises.push(extractPromise);
+    });
+    unzipStream.on("close", async () => {
+      try {
+        await Promise.all(extractPromises);
+        resolve2();
+      } catch (err) {
+        reject(err);
+      }
+    });
+    unzipStream.on("error", reject);
+  });
+}
+var receiveCommand = defineCommand8({
+  meta: {
+    name: "receive",
+    description: "Receive and extract shared AI IDE configs from a cursor-kit share URL"
+  },
+  args: {
+    url: {
+      type: "positional",
+      description: "The share URL (e.g., http://192.168.1.15:8080)",
+      required: true
+    },
+    force: {
+      type: "boolean",
+      alias: "f",
+      description: "Overwrite existing configs without prompting",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const { url, force } = args;
+    const cwd = process.cwd();
+    if (!isValidUrl(url)) {
+      p10.cancel("Invalid URL. Please provide a valid HTTP URL (e.g., http://192.168.1.15:8080)");
+      process.exit(1);
+    }
+    p10.intro(pc10.bgCyan(pc10.black(" cursor-kit receive ")));
+    console.log();
+    printInfo(`Source: ${highlight(url)}`);
+    printInfo(`Destination: ${highlight(cwd)}`);
+    console.log();
+    printDivider();
+    console.log();
+    const s = p10.spinner();
+    s.start("Connecting to server...");
+    let tempPath = null;
+    let receivedSize = 0;
+    try {
+      const result = await downloadToTemp(url);
+      tempPath = result.tempPath;
+      receivedSize = result.size;
+      s.stop("Connected and downloaded");
+      printInfo(`Received: ${highlight(formatBytes(receivedSize))}`);
+      console.log();
+      s.start("Reading metadata...");
+      const metadata = await readMetadataFromZip(tempPath);
+      if (!metadata || !metadata.configs || metadata.configs.length === 0) {
+        s.stop("Invalid share file");
+        printError("This doesn't appear to be a valid cursor-kit share.");
+        printInfo("The share file is missing required metadata.");
+        p10.cancel("Invalid share format");
+        removeFile(tempPath);
+        process.exit(1);
+      }
+      s.stop("Metadata loaded");
+      const configs = metadata.configs.map((type) => getConfigInfo(type, cwd));
+      const conflictingConfigs = configs.filter((c) => c.hasConflict);
+      printInfo("Configs in this share:");
+      for (const config of configs) {
+        const conflictIcon = config.hasConflict ? pc10.yellow("\u26A0") : pc10.green("\u25CF");
+        const conflictHint = config.hasConflict ? pc10.yellow(" (exists)") : "";
+        console.log(pc10.dim(`   \u2514\u2500 ${conflictIcon} ${config.label} (${config.directory})${conflictHint}`));
+      }
+      console.log();
+      let strategy = "overwrite";
+      if (conflictingConfigs.length > 0 && !force) {
+        const strategySelection = await p10.select({
+          message: `${conflictingConfigs.length} existing config(s) found. How do you want to handle conflicts?`,
+          options: [
+            {
+              value: "overwrite",
+              label: "Overwrite existing files",
+              hint: "Replace all conflicting files"
+            },
+            {
+              value: "merge",
+              label: "Merge (keep existing, add new only)",
+              hint: "Skip files that already exist"
+            },
+            {
+              value: "cancel",
+              label: "Cancel",
+              hint: "Abort the operation"
+            }
+          ]
+        });
+        if (p10.isCancel(strategySelection) || strategySelection === "cancel") {
+          p10.cancel("Operation cancelled");
+          removeFile(tempPath);
+          process.exit(0);
+        }
+        strategy = strategySelection;
+      }
+      s.start("Extracting configs...");
+      await extractWithStrategy(tempPath, cwd, configs, strategy);
+      s.stop("Configs extracted");
+      removeFile(tempPath);
+      console.log();
+      printDivider();
+      console.log();
+      for (const config of configs) {
+        const action = config.hasConflict ? strategy === "merge" ? "merged" : "replaced" : "added";
+        printSuccess(`${config.label}: ${highlight(action)}`);
+      }
+      console.log();
+      p10.outro(pc10.green("\u2728 Transfer complete!"));
+    } catch (error) {
+      s.stop("Failed");
+      if (tempPath) {
+        removeFile(tempPath);
+      }
+      let errorMessage = error instanceof Error ? error.message : "Unknown error";
+      if (errorMessage.includes("ECONNREFUSED")) {
+        errorMessage = "Connection refused. Make sure the share server is running.";
+      } else if (errorMessage.includes("ETIMEDOUT") || errorMessage.includes("timeout")) {
+        errorMessage = "Connection timed out. Check the URL and network connection.";
+      } else if (errorMessage.includes("ENOTFOUND")) {
+        errorMessage = "Host not found. Check the URL and network connection.";
+      } else if (errorMessage.includes("ECONNRESET") || errorMessage.includes("aborted")) {
+        errorMessage = "Connection was reset. The server may have closed unexpectedly.";
+      }
+      printError(errorMessage);
+      p10.cancel("Failed to receive configs");
+      process.exit(1);
+    }
+  }
+});
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
-var main = defineCommand7({
+var main = defineCommand9({
   meta: {
     name: "cursor-kit",
     version: pkg.version,
@@ -2904,7 +3477,9 @@ var main = defineCommand7({
     pull: pullCommand,
     list: listCommand,
     remove: removeCommand,
-    instance: instanceCommand
+    instance: instanceCommand,
+    share: shareCommand,
+    receive: receiveCommand
   }
 });
 runMain(main);