@liquidmetal-ai/raindrop 0.7.0 → 0.8.0

package/bundle/commands/logs/tail.js

@@ -0,0 +1,155 @@
+import {
+  displayTraceGroupedEvents
+} from "../../chunk-KXEV6E63.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  StreamLogsRequestSchema,
+  __toESM,
+  create,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/logs/tail.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Tail = class extends BaseCommand {
+  static args = {};
+  static description = "tail logs of applications deployed";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>`,
+    `<%= config.bin %> <%= command.id %> --application my-app`,
+    `<%= config.bin %> <%= command.id %> --application my-app --version v1.2.3`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "m",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      hidden: true
+    }),
+    application: import_core.Flags.string({
+      char: "a",
+      description: "application",
+      required: false
+    }),
+    version: import_core.Flags.string({
+      char: "v",
+      description: "application version",
+      required: false
+    }),
+    rainbowAuthService: import_core.Flags.string({
+      default: "https://liquidmetal.run/api/connect",
+      hidden: true,
+      env: "LIQUIDMETAL_RAINBOW_AUTH_SERVICE"
+    }),
+    raindropCatalogService: import_core.Flags.string({
+      env: "RAINDROP_CATALOG_SERVICE",
+      description: "URL of the catalog service",
+      hidden: true
+    })
+  };
+  async run() {
+    const apps = await this.loadManifest();
+    const config = await this.loadConfig();
+    if (!this.flags.version) {
+      if (!config.versionId) {
+        this.error("No version provided or found in config", { exit: 1 });
+      }
+      this.flags.version = config.versionId;
+    }
+    if (!this.flags.application) {
+      const app = apps[0];
+      if (app === void 0) {
+        this.error("No application provided or found in manifest", { exit: 1 });
+      }
+      this.flags.application = valueOf(app.name);
+    }
+    const {
+      userId,
+      client: riverjackService,
+      organizationId: defaultOrganizationId
+    } = await this.tenantRiverjackService();
+    const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+    this.log(`Using organization: ${organizationId}`);
+    this.log(`Using user: ${userId}`);
+    this.log(`Tailing logs for ${this.flags.application}@${this.flags.version} using Riverjack service...`);
+    this.log("Press Ctrl+C to stop\n");
+    try {
+      const request = create(StreamLogsRequestSchema, {
+        organizationId,
+        userId,
+        applicationName: this.flags.application,
+        applicationVersionId: this.flags.version
+      });
+      for await (const resp of riverjackService.streamLogs(request)) {
+        if (this.flags.output === "json") {
+          this.log(JSON.stringify(resp, null, 2));
+          continue;
+        }
+        switch (resp.responseType) {
+          case "heartbeat":
+            break;
+          case "stream_started":
+            this.log(`\u{1F504} Started streaming logs for ${this.flags.application}@${this.flags.version}`);
+            this.log(`   Organization: ${organizationId}`);
+            this.log(`   User: ${userId}`);
+            if (resp.timestamp) {
+              this.log(`   Time: ${new Date(resp.timestamp).toLocaleString()}`);
+            }
+            break;
+          case "events":
+            if (resp.events && resp.events.length > 0) {
+              displayTraceGroupedEvents(resp.events, { log: (message) => this.log(message) });
+            }
+            break;
+          case "stream_ended":
+            this.log(`\u2705 Stream ended`);
+            if (resp.timestamp) {
+              this.log(`   End time: ${new Date(resp.timestamp).toLocaleString()}`);
+            }
+            break;
+          case "service_error":
+            this.log(`\u274C Service error`);
+            if (resp.message) {
+              this.log(`   Error: ${resp.message}`);
+            }
+            if (resp.timestamp) {
+              this.log(`   Time: ${new Date(resp.timestamp).toLocaleString()}`);
+            }
+            break;
+          default:
+            if (resp.message) {
+              this.log(resp.message);
+            }
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        this.error(`Failed to tail logs: ${error.message}`, { exit: 1 });
+      } else {
+        this.error("Failed to tail logs: Unknown error", { exit: 1 });
+      }
+    }
+  }
+};
+export {
+  Tail as default
+};

package/bundle/commands/mcp/install-claude.js

@@ -0,0 +1,220 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  init_cjs_shims,
+  urlifyOrganizationId
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/mcp/install-claude.ts
+init_cjs_shims();
+import { spawn } from "node:child_process";
+import { readFile, writeFile, mkdir, access } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { constants } from "node:fs";
+var McpInstallClaude = class extends BaseCommand {
+  static description = "Install complete Raindrop integration for Claude Code IDE";
+  static examples = [
+    `<%= config.bin %> mcp install-claude
+Install Raindrop MCP server and Claude Code configuration files
+
+This command will:
+- Check if Claude CLI is installed and accessible
+- Verify if raindrop-mcp server already exists (prevents duplicates)
+- Add the raindrop-mcp server to your Claude Code MCP configuration
+- Create Claude Code slash commands in ~/.claude/commands/:
+  \u2022 /new-raindrop-app - Start new Raindrop application development
+  \u2022 /update-raindrop-app - Update existing Raindrop applications
+  \u2022 /reattach-raindrop-session - Resume previous development sessions
+
+Requirements:
+- Claude CLI must be installed (https://claude.ai/download)
+- You must be logged into your Raindrop organization via 'raindrop auth login'
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS
+  };
+  async run() {
+    await this.installClaudeIntegration();
+    await this.createClaudeConfigFiles();
+  }
+  async installClaudeIntegration() {
+    console.log("\u{1F50D} Checking if Claude CLI is installed...");
+    if (!await this.checkClaudeInstalled()) {
+      this.error("Claude CLI is not installed. Please install it first: https://claude.ai/download", { exit: 1 });
+    }
+    console.log("Claude CLI is installed");
+    console.log("\u{1F50D} Checking for existing MCP server...");
+    if (await this.checkMcpServerExists()) {
+      console.log('MCP server "raindrop-mcp" already exists in Claude Code configuration');
+      console.log("");
+      console.log("To update the existing server:");
+      console.log("  1. Remove the existing server: claude mcp remove raindrop-mcp");
+      console.log("  2. Run this command again: raindrop mcp install-claude");
+      console.log("");
+      console.log("Or manually update the server URL in your Claude Code MCP settings.");
+      this.error("MCP server already exists. Please remove it first before adding a new one.", { exit: 1 });
+    }
+    console.log("\u{1F50D} Getting organization identity...");
+    let identity;
+    try {
+      identity = await this.catalogIdentity();
+      console.log(`Organization ID: ${identity.organizationId}`);
+    } catch (error) {
+      console.log(`Failed to get identity: ${error.message}`);
+      this.error(`Failed to get organization identity: ${error.message}`, { exit: 1 });
+    }
+    const urlSafeOrgId = urlifyOrganizationId(identity.organizationId);
+    const mcpUrl = `https://raindrop-mcp.${urlSafeOrgId}.lmapp.run/mcp`;
+    console.log(`\u{1F50D} MCP URL: ${mcpUrl}`);
+    if (await this.checkMcpAlreadyConfigured()) {
+      console.log("\u2705 MCP integration already configured.");
+      console.log("\u{1F4A1} Use `raindrop mcp status` to check current configuration.");
+      return;
+    }
+    try {
+      console.log("\u{1F50D} Executing Claude MCP command...");
+      await this.executeClaudeCommand(["mcp", "add", "--transport", "http", "raindrop-mcp", mcpUrl]);
+      console.log("MCP integration for Claude Code installed successfully");
+      console.log(`Server URL: ${mcpUrl}`);
+    } catch (error) {
+      console.log(`Claude command failed: ${error.message}`);
+      this.error(`Failed to configure Claude MCP integration: ${error.message}`, { exit: 1 });
+    }
+  }
+  async createClaudeConfigFiles() {
+    try {
+      const home = homedir();
+      const raindropDir = join(home, ".raindrop");
+      const claudeDir = join(home, ".claude");
+      const commandsDir = join(claudeDir, "commands");
+      await mkdir(raindropDir, { recursive: true });
+      await mkdir(claudeDir, { recursive: true });
+      await mkdir(commandsDir, { recursive: true });
+      const currentFileUrl = import.meta.url;
+      const currentDir = dirname(fileURLToPath(currentFileUrl));
+      let packageRoot = currentDir;
+      while (packageRoot !== dirname(packageRoot)) {
+        try {
+          await access(join(packageRoot, "package.json"), constants.F_OK);
+          break;
+        } catch {
+          packageRoot = dirname(packageRoot);
+        }
+      }
+      const templatesDir = join(packageRoot, "templates", "claude-code");
+      const fileMap = [
+        ["new-raindrop-app.md", join(commandsDir, "new-raindrop-app.md"), "New app command"],
+        ["update-raindrop-app.md", join(commandsDir, "update-raindrop-app.md"), "Update app command"],
+        ["reattach-raindrop-session.md", join(commandsDir, "reattach-raindrop-session.md"), "Reattach session command"]
+      ];
+      const createdFiles = [];
+      const skippedFiles = [];
+      const existingFiles = [];
+      for (const [, destPath] of fileMap) {
+        try {
+          await access(destPath, constants.F_OK);
+          existingFiles.push(destPath);
+        } catch {
+        }
+      }
+      for (const [templateFile, destPath, description] of fileMap) {
+        try {
+          const templatePath = join(templatesDir, templateFile);
+          const content = await readFile(templatePath, "utf-8");
+          await writeFile(destPath, content, "utf-8");
+          createdFiles.push(destPath);
+        } catch (error) {
+          console.log(`Failed to create ${description}: ${error.message}`);
+          skippedFiles.push(destPath);
+        }
+      }
+      if (createdFiles.length > 0) {
+        console.log("\u{1F4DD} Created Claude Code configuration files:");
+        for (const filePath of createdFiles) {
+          console.log(`   ${filePath}`);
+        }
+      }
+      if (skippedFiles.length > 0) {
+        console.log("Skipped files due to errors:");
+        for (const filePath of skippedFiles) {
+          console.log(`   ${filePath}`);
+        }
+      }
+      if (createdFiles.length > 0) {
+        console.log("Restart Claude Code for changes to take effect");
+      }
+    } catch (error) {
+      this.error(`Failed to create Claude configuration files: ${error.message}`, { exit: 1 });
+    }
+  }
+  async checkClaudeInstalled() {
+    return new Promise((resolve) => {
+      const childProcess = spawn("claude", ["--version"], { stdio: "ignore" });
+      childProcess.on("close", (code) => resolve(code === 0));
+      childProcess.on("error", () => resolve(false));
+    });
+  }
+  async checkMcpServerExists() {
+    return new Promise((resolve) => {
+      const childProcess = spawn("claude", ["mcp", "list"], { stdio: "pipe" });
+      let output = "";
+      childProcess.stdout?.on("data", (data) => {
+        output += data.toString();
+      });
+      childProcess.on("close", (code) => {
+        if (code !== 0) {
+          resolve(false);
+          return;
+        }
+        resolve(output.includes("raindrop-mcp"));
+      });
+      childProcess.on("error", () => resolve(false));
+    });
+  }
+  async executeClaudeCommand(args) {
+    return new Promise((resolve, reject) => {
+      const childProcess = spawn("claude", args, {
+        stdio: "inherit"
+        // Show output to user so we can see errors
+      });
+      childProcess.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Claude MCP command failed with exit code ${code}`));
+        }
+      });
+      childProcess.on("error", (error) => {
+        reject(new Error(`Failed to execute Claude CLI: ${error.message}`));
+      });
+    });
+  }
+  async checkMcpAlreadyConfigured() {
+    return new Promise((resolve) => {
+      const childProcess = spawn("claude", ["mcp", "list"], {
+        stdio: "pipe"
+      });
+      let output = "";
+      childProcess.stdout?.on("data", (data) => {
+        output += data.toString();
+      });
+      childProcess.on("close", (code) => {
+        if (code === 0) {
+          resolve(output.includes("raindrop-mcp"));
+        } else {
+          resolve(false);
+        }
+      });
+      childProcess.on("error", () => {
+        resolve(false);
+      });
+    });
+  }
+};
+export {
+  McpInstallClaude as default
+};

package/bundle/commands/mcp/install-gemini.js

@@ -0,0 +1,220 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  init_cjs_shims,
+  urlifyOrganizationId
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/mcp/install-gemini.ts
+init_cjs_shims();
+import { spawn } from "node:child_process";
+import { readFile, writeFile, mkdir, access } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { constants } from "node:fs";
+var McpInstallGemini = class extends BaseCommand {
+  static description = "Install complete Raindrop integration for Gemini CLI";
+  static examples = [
+    `<%= config.bin %> mcp install-gemini
+Install Raindrop MCP server and Gemini CLI configuration files
+
+This command will:
+- Check if Gemini CLI is installed and accessible
+- Verify if raindrop-mcp server already exists (prevents duplicates)
+- Add the raindrop-mcp server to your Gemini CLI MCP configuration
+- Create Gemini CLI slash commands in ~/.gemini/commands/ (TOML format):
+  \u2022 /new-raindrop-app - Start new Raindrop application development
+  \u2022 /update-raindrop-app - Update existing Raindrop applications
+  \u2022 /reattach-raindrop-session - Resume previous development sessions
+
+Requirements:
+- Gemini CLI must be installed
+- You must be logged into your Raindrop organization via 'raindrop auth login'
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS
+  };
+  async run() {
+    await this.installGeminiIntegration();
+    await this.createGeminiConfigFiles();
+  }
+  async installGeminiIntegration() {
+    console.log("\u{1F50D} Checking if Gemini CLI is installed...");
+    if (!await this.checkGeminiInstalled()) {
+      this.error("Gemini CLI is not installed. Please install it first at https://github.com/google-gemini/gemini-cli.", { exit: 1 });
+    }
+    console.log("Gemini CLI is installed");
+    console.log("\u{1F50D} Checking for existing MCP server...");
+    if (await this.checkMcpServerExists()) {
+      console.log('MCP server "raindrop-mcp" already exists in Gemini CLI configuration');
+      console.log("");
+      console.log("To update the existing server:");
+      console.log("  1. Remove the existing server: gemini mcp remove raindrop-mcp");
+      console.log("  2. Run this command again: raindrop mcp install-gemini");
+      console.log("");
+      console.log("Or manually update the server URL in your Gemini CLI MCP settings.");
+      this.error("MCP server already exists. Please remove it first before adding a new one.", { exit: 1 });
+    }
+    console.log("\u{1F50D} Getting organization identity...");
+    let identity;
+    try {
+      identity = await this.catalogIdentity();
+      console.log(`Organization ID: ${identity.organizationId}`);
+    } catch (error) {
+      console.log(`Failed to get identity: ${error.message}`);
+      this.error(`Failed to get organization identity: ${error.message}`, { exit: 1 });
+    }
+    const urlSafeOrgId = urlifyOrganizationId(identity.organizationId);
+    const mcpUrl = `https://raindrop-mcp.${urlSafeOrgId}.lmapp.run/mcp`;
+    console.log(`\u{1F50D} MCP URL: ${mcpUrl}`);
+    if (await this.checkMcpAlreadyConfigured()) {
+      console.log("\u2705 MCP integration already configured.");
+      console.log("\u{1F4A1} Use `raindrop mcp status` to check current configuration.");
+      return;
+    }
+    try {
+      console.log("\u{1F50D} Executing Gemini MCP command...");
+      await this.executeGeminiCommand(["mcp", "add", "--transport", "http", "raindrop-mcp", mcpUrl, "--trust"]);
+      console.log("MCP integration for Gemini installed successfully");
+      console.log(`Server URL: ${mcpUrl}`);
+    } catch (error) {
+      console.log(`Gemini command failed: ${error.message}`);
+      this.error(`Failed to configure Gemini MCP integration: ${error.message}`, { exit: 1 });
+    }
+  }
+  async createGeminiConfigFiles() {
+    try {
+      const home = homedir();
+      const raindropDir = join(home, ".raindrop");
+      const geminiDir = join(home, ".gemini");
+      const commandsDir = join(geminiDir, "commands");
+      await mkdir(raindropDir, { recursive: true });
+      await mkdir(geminiDir, { recursive: true });
+      await mkdir(commandsDir, { recursive: true });
+      const currentFileUrl = import.meta.url;
+      const currentDir = dirname(fileURLToPath(currentFileUrl));
+      let packageRoot = currentDir;
+      while (packageRoot !== dirname(packageRoot)) {
+        try {
+          await access(join(packageRoot, "package.json"), constants.F_OK);
+          break;
+        } catch {
+          packageRoot = dirname(packageRoot);
+        }
+      }
+      const templatesDir = join(packageRoot, "templates", "gemini-code");
+      const fileMap = [
+        ["new-raindrop-app.toml", join(commandsDir, "new-raindrop-app.toml"), "New app command"],
+        ["update-raindrop-app.toml", join(commandsDir, "update-raindrop-app.toml"), "Update app command"],
+        ["reattach-raindrop-session.toml", join(commandsDir, "reattach-raindrop-session.toml"), "Reattach session command"]
+      ];
+      const createdFiles = [];
+      const skippedFiles = [];
+      const existingFiles = [];
+      for (const [, destPath] of fileMap) {
+        try {
+          await access(destPath, constants.F_OK);
+          existingFiles.push(destPath);
+        } catch {
+        }
+      }
+      for (const [templateFile, destPath, description] of fileMap) {
+        try {
+          const templatePath = join(templatesDir, templateFile);
+          const content = await readFile(templatePath, "utf-8");
+          await writeFile(destPath, content, "utf-8");
+          createdFiles.push(destPath);
+        } catch (error) {
+          console.log(`Failed to create ${description}: ${error.message}`);
+          skippedFiles.push(destPath);
+        }
+      }
+      if (createdFiles.length > 0) {
+        console.log("\u{1F4DD} Created Gemini CLI configuration files:");
+        for (const filePath of createdFiles) {
+          console.log(`   ${filePath}`);
+        }
+      }
+      if (skippedFiles.length > 0) {
+        console.log("Skipped files due to errors:");
+        for (const filePath of skippedFiles) {
+          console.log(`   ${filePath}`);
+        }
+      }
+      if (createdFiles.length > 0) {
+        console.log("Start or Restart Gemini CLI for changes to take effect");
+      }
+    } catch (error) {
+      this.error(`Failed to create Gemini configuration files: ${error.message}`, { exit: 1 });
+    }
+  }
+  async checkGeminiInstalled() {
+    return new Promise((resolve) => {
+      const childProcess = spawn("gemini", ["--version"], { stdio: "ignore" });
+      childProcess.on("close", (code) => resolve(code === 0));
+      childProcess.on("error", () => resolve(false));
+    });
+  }
+  async checkMcpServerExists() {
+    return new Promise((resolve) => {
+      const childProcess = spawn("gemini", ["mcp", "list"], { stdio: "pipe" });
+      let output = "";
+      childProcess.stdout?.on("data", (data) => {
+        output += data.toString();
+      });
+      childProcess.on("close", (code) => {
+        if (code !== 0) {
+          resolve(false);
+          return;
+        }
+        resolve(output.includes("raindrop-mcp"));
+      });
+      childProcess.on("error", () => resolve(false));
+    });
+  }
+  async executeGeminiCommand(args) {
+    return new Promise((resolve, reject) => {
+      const childProcess = spawn("gemini", args, {
+        stdio: "inherit"
+        // Show output to user so we can see errors
+      });
+      childProcess.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Gemini MCP command failed with exit code ${code}`));
+        }
+      });
+      childProcess.on("error", (error) => {
+        reject(new Error(`Failed to execute Gemini CLI: ${error.message}`));
+      });
+    });
+  }
+  async checkMcpAlreadyConfigured() {
+    return new Promise((resolve) => {
+      const childProcess = spawn("gemini", ["mcp", "list"], {
+        stdio: "pipe"
+      });
+      let output = "";
+      childProcess.stdout?.on("data", (data) => {
+        output += data.toString();
+      });
+      childProcess.on("close", (code) => {
+        if (code === 0) {
+          resolve(output.includes("raindrop-mcp"));
+        } else {
+          resolve(false);
+        }
+      });
+      childProcess.on("error", () => {
+        resolve(false);
+      });
+    });
+  }
+};
+export {
+  McpInstallGemini as default
+};