@liquidmetal-ai/raindrop 0.7.0 → 0.8.0

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

@@ -0,0 +1,232 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  init_cjs_shims,
+  urlifyOrganizationId
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/mcp/install-goose.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 McpInstallGoose = class extends BaseCommand {
+  static description = "Install complete Raindrop integration for Goose";
+  static examples = [
+    `<%= config.bin %> mcp install-goose
+Install Raindrop MCP server and Goose configuration files
+
+This command will:
+- Check if Goose is installed and accessible
+- Verify if raindrop-mcp server already exists (prevents duplicates)
+- Add the raindrop-mcp extension to your Goose configuration
+- Create Goose recipe files in ~/.config/goose/recipes/:
+  \u2022 new-raindrop-app.yaml - Start new Raindrop application development
+  \u2022 update-raindrop-app.yaml - Update existing Raindrop applications
+  \u2022 reattach-raindrop-session.yaml - Resume previous development sessions
+
+Requirements:
+- Goose must be installed (https://block.github.io/goose/)
+- You must be logged into your Raindrop organization via 'raindrop auth login'
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS
+  };
+  async run() {
+    await this.installGooseIntegration();
+    await this.createGooseConfigFiles();
+  }
+  async installGooseIntegration() {
+    console.log("\u{1F50D} Checking if Goose is installed...");
+    if (!await this.checkGooseInstalled()) {
+      this.error("Goose is not installed. Please install it first: https://block.github.io/goose/", { exit: 1 });
+    }
+    console.log("Goose is installed");
+    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}`);
+    await this.updateGooseConfig(mcpUrl);
+  }
+  async updateGooseConfig(mcpUrl) {
+    const home = homedir();
+    const configPath = join(home, ".config", "goose", "config.yaml");
+    try {
+      await mkdir(dirname(configPath), { recursive: true });
+      let configContent = {};
+      try {
+        const existingConfig = await readFile(configPath, "utf-8");
+        configContent = this.parseYaml(existingConfig);
+      } catch {
+        console.log("Creating new Goose config.yaml file...");
+      }
+      if (!configContent.extensions) {
+        configContent.extensions = {};
+      }
+      if (configContent.extensions["raindrop-mcp"]) {
+        console.log('MCP extension "raindrop-mcp" already exists in Goose configuration');
+        console.log("");
+        console.log("To update the existing extension:");
+        console.log("  1. Edit ~/.config/goose/config.yaml manually");
+        console.log("  2. Update the raindrop-mcp extension URL");
+        console.log("");
+        this.error("MCP extension already exists. Please update it manually if needed.", { exit: 1 });
+      }
+      configContent.extensions["raindrop-mcp"] = {
+        enabled: true,
+        name: "raindrop-mcp",
+        timeout: 300,
+        type: "http",
+        url: mcpUrl
+      };
+      const yamlContent = this.stringifyYaml(configContent);
+      await writeFile(configPath, yamlContent, "utf-8");
+      console.log("MCP integration for Goose installed successfully");
+      console.log(`Configuration updated: ${configPath}`);
+      console.log(`Server URL: ${mcpUrl}`);
+    } catch (error) {
+      console.log(`Failed to update Goose config: ${error.message}`);
+      this.error(`Failed to configure Goose MCP integration: ${error.message}`, { exit: 1 });
+    }
+  }
+  async createGooseConfigFiles() {
+    try {
+      const home = homedir();
+      const raindropDir = join(home, ".raindrop");
+      const gooseRecipesDir = join(home, ".config", "goose", "recipes");
+      await mkdir(raindropDir, { recursive: true });
+      await mkdir(gooseRecipesDir, { 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");
+      const fileMap = [
+        [join("goose", "new-raindrop-app.yaml"), join(gooseRecipesDir, "new-raindrop-app.yaml"), "New app recipe"],
+        [join("goose", "update-raindrop-app.yaml"), join(gooseRecipesDir, "update-raindrop-app.yaml"), "Update app recipe"],
+        [join("goose", "reattach-raindrop-session.yaml"), join(gooseRecipesDir, "reattach-raindrop-session.yaml"), "Reattach session recipe"]
+      ];
+      const createdFiles = [];
+      const skippedFiles = [];
+      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 Goose 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("");
+        console.log("To use Raindrop with Goose:");
+        console.log("  goose session --recipe ~/.config/goose/recipes/new-raindrop-app.yaml");
+        console.log("  goose session --recipe ~/.config/goose/recipes/update-raindrop-app.yaml");
+        console.log("  goose session --recipe ~/.config/goose/recipes/reattach-raindrop-session.yaml");
+      }
+    } catch (error) {
+      this.error(`Failed to create Goose configuration files: ${error.message}`, { exit: 1 });
+    }
+  }
+  async checkGooseInstalled() {
+    return new Promise((resolve) => {
+      const childProcess = spawn("goose", ["--version"], { stdio: "ignore" });
+      childProcess.on("close", (code) => resolve(code === 0));
+      childProcess.on("error", () => resolve(false));
+    });
+  }
+  parseYaml(content) {
+    const lines = content.split("\n");
+    const config = {};
+    const extensions = {};
+    let currentExtension = null;
+    let inExtensions = false;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("extensions:")) {
+        inExtensions = true;
+        continue;
+      }
+      if (inExtensions) {
+        if (trimmed && !trimmed.startsWith(" ") && !line.startsWith("  ")) {
+          inExtensions = false;
+        } else if (trimmed.match(/^[\w-]+:$/)) {
+          currentExtension = trimmed.slice(0, -1);
+          extensions[currentExtension] = {
+            enabled: true,
+            name: currentExtension,
+            timeout: 300,
+            type: "http",
+            url: ""
+          };
+        } else if (currentExtension && trimmed.includes(":")) {
+          const ext = extensions[currentExtension];
+          if (!ext) continue;
+          const [key, ...valueParts] = trimmed.split(":");
+          const value = valueParts.join(":").trim().replace(/^["']|["']$/g, "");
+          if (key === "enabled") ext.enabled = value === "true";
+          if (key === "name") ext.name = value;
+          if (key === "timeout") ext.timeout = Number.parseInt(value, 10);
+          if (key === "type") ext.type = value;
+          if (key === "url") ext.url = value;
+        }
+      }
+    }
+    if (Object.keys(extensions).length > 0) {
+      config.extensions = extensions;
+    }
+    return config;
+  }
+  stringifyYaml(config) {
+    const lines = [];
+    if (config.extensions) {
+      lines.push("extensions:");
+      for (const [name, ext] of Object.entries(config.extensions)) {
+        lines.push(`  ${name}:`);
+        lines.push(`    enabled: ${ext.enabled}`);
+        lines.push(`    name: ${ext.name}`);
+        lines.push(`    timeout: ${ext.timeout}`);
+        lines.push(`    type: ${ext.type}`);
+        lines.push(`    url: "${ext.url}"`);
+      }
+    }
+    return lines.join("\n") + "\n";
+  }
+};
+export {
+  McpInstallGoose as default
+};

package/bundle/commands/mcp/status.js

@@ -0,0 +1,153 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  urlifyOrganizationId
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/mcp/status.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+import { spawn } from "node:child_process";
+var McpStatus = class _McpStatus extends BaseCommand {
+  static args = {};
+  static description = "show the status of MCP (Model Context Protocol) integration for Claude IDE";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+Show current MCP integration status
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_McpStatus);
+    if (!await this.checkClaudeInstalled()) {
+      this.error("Claude CLI is not installed. Please install it first: https://claude.ai/download", { exit: 1 });
+    }
+    try {
+      const identity = await this.catalogIdentity();
+      const urlSafeOrgId = urlifyOrganizationId(identity.organizationId);
+      const expectedMcpUrl = `https://raindrop-mcp.${urlSafeOrgId}.lmapp.run/mcp`;
+      const mcpServers = await this.getMcpServers();
+      const raindropMcp = mcpServers.find((server) => server.name === "raindrop-mcp");
+      if (flags.output === "json") {
+        const status = {
+          raindropMcp: raindropMcp ? {
+            configured: true,
+            name: raindropMcp.name,
+            url: raindropMcp.url,
+            transport: raindropMcp.transport,
+            urlMatches: raindropMcp.url === expectedMcpUrl,
+            expectedUrl: expectedMcpUrl
+          } : {
+            configured: false,
+            expectedUrl: expectedMcpUrl
+          },
+          allServers: mcpServers,
+          claudeInstalled: true
+        };
+        console.log(JSON.stringify(status, null, 2));
+      } else {
+        if (raindropMcp) {
+          console.log("\u2705 Raindrop MCP integration is configured");
+          console.log(`   Name: ${raindropMcp.name}`);
+          console.log(`   URL: ${raindropMcp.url}`);
+          console.log(`   Transport: ${raindropMcp.transport}`);
+          if (raindropMcp.url === expectedMcpUrl) {
+            console.log("\u2705 Server URL matches current organization");
+          } else {
+            console.log("\u26A0\uFE0F  Server URL does not match current organization");
+            console.log(`   Expected: ${expectedMcpUrl}`);
+          }
+        } else {
+          console.log("\u274C Raindrop MCP integration is not configured");
+          console.log("\u{1F4A1} Run `raindrop mcp install-claude` to set it up");
+        }
+        if (mcpServers.length > 0) {
+          console.log(`
+All configured MCP servers (${mcpServers.length}):`);
+          for (const server of mcpServers) {
+            const icon = server.name === "raindrop-mcp" ? "\u{1F535}" : "\u26AA";
+            console.log(`   ${icon} ${server.name} (${server.transport}) - ${server.url}`);
+          }
+        } else {
+          console.log("\nNo MCP servers configured");
+        }
+      }
+    } catch (error) {
+      const err = error;
+      this.error(`Failed to get MCP status: ${err.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 getMcpServers() {
+    return new Promise((resolve, reject) => {
+      const childProcess = spawn("claude", ["mcp", "list"], {
+        stdio: "pipe"
+      });
+      let output = "";
+      let errorOutput = "";
+      if (childProcess.stdout) {
+        childProcess.stdout.on("data", (data) => {
+          output += data.toString();
+        });
+      }
+      if (childProcess.stderr) {
+        childProcess.stderr.on("data", (data) => {
+          errorOutput += data.toString();
+        });
+      }
+      childProcess.on("close", (code) => {
+        if (code === 0) {
+          resolve(this.parseMcpList(output));
+        } else {
+          reject(new Error(`Failed to get MCP server list: ${errorOutput || "Command failed"}`));
+        }
+      });
+      childProcess.on("error", (error) => {
+        reject(new Error(`Failed to execute Claude CLI: ${error.message}`));
+      });
+    });
+  }
+  parseMcpList(output) {
+    const servers = [];
+    const lines = output.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("Checking MCP server health") || trimmed.startsWith("MCP Servers:") || trimmed.startsWith("Name")) {
+        continue;
+      }
+      const match = trimmed.match(/^([^:]+):\s+([^\s]+)\s+\(([^)]+)\)/);
+      if (match && match[1] && match[2] && match[3]) {
+        const name = match[1].trim();
+        const url = match[2].trim();
+        const transport = match[3].trim().toLowerCase();
+        servers.push({
+          name,
+          url,
+          transport
+        });
+      }
+    }
+    return servers;
+  }
+};
+export {
+  McpStatus as default
+};

package/bundle/commands/object/delete.js

@@ -0,0 +1,180 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  DeleteObjectResponseSchema,
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  toJsonString
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/object/delete.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var ObjectDelete = class extends BaseCommand {
+  static args = {
+    key: import_core.Args.string({
+      description: "key/path in the bucket to delete",
+      required: true
+    })
+  };
+  static description = "Delete a file from the object storage";
+  static examples = [
+    `<%= config.bin %> object delete my-key --bucket my-bucket
+Delete file with key 'my-key' from my-bucket
+`,
+    `<%= config.bin %> object delete my-key --application my-app --bucket my-bucket
+Delete file with key 'my-key' from my-bucket within my-app
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    bucket: import_core.Flags.string({
+      char: "b",
+      description: "bucket name version can be specified with #, e.g. my-bucket#versionId",
+      required: false
+    }),
+    moduleId: import_core.Flags.string({
+      char: "m",
+      description: "moduleId",
+      required: false
+    }),
+    application: import_core.Flags.string({
+      char: "a",
+      description: "application name",
+      required: false
+    }),
+    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
+    })
+  };
+  async run() {
+    if (this.flags.bucket && this.flags.moduleId) {
+      this.error("Cannot specify both --bucket and --moduleId flags.");
+    }
+    if (this.flags.moduleId && this.flags.application) {
+      this.error("Cannot specify both --moduleId and --application flags.");
+    }
+    if (!this.flags.bucket && !this.flags.moduleId && !this.flags.application) {
+      this.error("Must specify one of: --bucket, --moduleId, or --application");
+    }
+    const { client: objectService, userId, organizationId } = await this.objectService();
+    let bucketLocation;
+    if (this.flags.moduleId) {
+      bucketLocation = {
+        bucketLocation: {
+          case: "moduleId",
+          value: this.flags.moduleId
+        }
+      };
+    } else if (this.flags.application && this.flags.bucket) {
+      const applicationName = this.flags.application;
+      const config = await this.loadConfig();
+      const applicationVersionId = config.versionId || void 0;
+      const { client: catalogService } = await this.catalogService();
+      const queryParams = {
+        userId,
+        applicationName,
+        organizationId,
+        moduleType: "smartbucket",
+        ...applicationVersionId && { applicationVersionId }
+      };
+      const modulesResp = await catalogService.queryModules(queryParams);
+      if (!modulesResp.modules || modulesResp.modules.length === 0) {
+        this.error(`No bucket modules found for application '${applicationName}'`);
+      }
+      const bucketName = this.flags.bucket.split("#")[0];
+      const bucketModules = modulesResp.modules.filter((module) => module.name === bucketName);
+      if (bucketModules.length === 0) {
+        this.error(`Bucket '${bucketName}' not found in application '${applicationName}'`);
+      }
+      const bucketModule = applicationVersionId ? bucketModules.find((m) => m.applicationVersionId === applicationVersionId) || bucketModules.sort((a, b) => b.applicationVersionId.localeCompare(a.applicationVersionId))[0] : bucketModules.sort((a, b) => b.applicationVersionId.localeCompare(a.applicationVersionId))[0];
+      if (!bucketModule) {
+        this.error(`Bucket '${bucketName}' not found in application '${applicationName}'`);
+      }
+      bucketLocation = {
+        bucketLocation: {
+          case: "bucket",
+          value: {
+            name: bucketName,
+            version: bucketModule.applicationVersionId
+          }
+        }
+      };
+    } else if (this.flags.bucket) {
+      if (!this.flags.bucket.includes("#")) {
+        await this.loadConfig();
+      }
+      bucketLocation = {
+        bucketLocation: {
+          case: "bucket",
+          value: {
+            name: this.flags.bucket.split("#")[0],
+            version: this.flags.bucket.includes("#") ? this.flags.bucket.split("#")[1] : this.raindropConfig?.versionId
+          }
+        }
+      };
+    } else if (this.flags.application) {
+      const applicationName = this.flags.application;
+      const config = await this.loadConfig();
+      const applicationVersionId = config.versionId || void 0;
+      const { client: catalogService } = await this.catalogService();
+      const queryParams = {
+        userId,
+        applicationName,
+        organizationId,
+        moduleType: "smartbucket",
+        ...applicationVersionId && { applicationVersionId }
+      };
+      const modulesResp = await catalogService.queryModules(queryParams);
+      if (!modulesResp.modules || modulesResp.modules.length === 0) {
+        this.error(`No bucket modules found for application '${applicationName}'`);
+      }
+      const bucketModule = modulesResp.modules[0];
+      if (!bucketModule) {
+        this.error(`No bucket modules found for application '${applicationName}'`);
+      }
+      bucketLocation = {
+        bucketLocation: {
+          case: "bucket",
+          value: {
+            name: bucketModule.name,
+            version: bucketModule.applicationVersionId
+          }
+        }
+      };
+    }
+    const response = await objectService.deleteObject({
+      userId,
+      organizationId,
+      bucketLocation,
+      key: this.args.key
+    });
+    if (this.flags.output === "json") {
+      console.log(toJsonString(DeleteObjectResponseSchema, response, { prettySpaces: 2 }));
+    } else {
+      console.log("Successfully deleted file:");
+      console.log(`Key: ${this.args.key}`);
+    }
+  }
+};
+export {
+  ObjectDelete as default
+};