@liquidmetal-ai/raindrop 0.7.0 → 0.8.1

package/bundle/commands/build/deploy.js

@@ -0,0 +1,160 @@
+import {
+  watchStatus
+} from "../../chunk-NG7CZTTE.js";
+import {
+  deploy,
+  sandbox
+} from "../../chunk-XYJACVNA.js";
+import "../../chunk-MGM2L2T3.js";
+import "../../chunk-VXAZKB3J.js";
+import "../../chunk-W2L3MYN6.js";
+import "../../chunk-MVQYQJHI.js";
+import "../../chunk-PU4RCSXF.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/deploy.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+
+// src/utils/directory-validation.ts
+init_cjs_shims();
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var DirectoryValidationError = class extends Error {
+  constructor(message, suggestedActions = []) {
+    super(message);
+    this.suggestedActions = suggestedActions;
+    this.name = "DirectoryValidationError";
+  }
+  isDirectoryValidationError = true;
+};
+async function validateRaindropDirectory(root, manifest = "raindrop.manifest") {
+  const manifestPath = path.isAbsolute(manifest) ? manifest : path.join(root, manifest);
+  try {
+    await fs.access(manifestPath, fs.constants.F_OK);
+  } catch (_error) {
+    const relativePath = path.relative(process.cwd(), root);
+    const displayPath = relativePath === "" ? "current directory" : relativePath;
+    throw new DirectoryValidationError(
+      `Error: Not in a raindrop directory. No raindrop.manifest found in ${displayPath}.`,
+      [
+        "Check if you are in the correct directory",
+        "Navigate to a raindrop project directory using: cd <project-directory>",
+        "Initialize a new raindrop project using: raindrop build init"
+      ]
+    );
+  }
+}
+function isDirectoryValidationError(error) {
+  return error instanceof DirectoryValidationError;
+}
+
+// src/commands/build/deploy.ts
+var Deploy = class extends BaseCommand {
+  static args = {};
+  static description = "deploy a Raindrop application";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> .
+Deploy a Raindrop application version.
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    root: import_core.Flags.string({ char: "r", description: "root directory", required: false, default: process.cwd() }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest"
+    }),
+    output: import_core.Flags.string({ char: "o", description: "output directory", required: false, default: "dist" }),
+    versionId: import_core.Flags.string({
+      char: "v",
+      aliases: ["version"],
+      description: "version ID",
+      required: false
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    start: import_core.Flags.boolean({
+      char: "s",
+      description: "start the application after deploying",
+      required: false,
+      default: false
+    }),
+    "no-watch": import_core.Flags.boolean({
+      description: "skip watching deployment status after deploy",
+      required: false,
+      default: false
+    }),
+    lock: import_core.Flags.string({
+      description: "override lock ID to resume deployment",
+      required: false
+    }),
+    amend: import_core.Flags.boolean({ char: "a", description: "amend an existing application", required: false, default: false })
+  };
+  async run() {
+    try {
+      await validateRaindropDirectory(this.flags.root, this.flags.manifest);
+    } catch (error) {
+      if (isDirectoryValidationError(error)) {
+        this.error(
+          error.message + "\n\nSuggested actions:\n" + error.suggestedActions?.map((action) => `  \u2022 ${action}`).join("\n"),
+          { exit: 1 }
+        );
+      }
+      throw error;
+    }
+    const config = await this.loadConfig();
+    const versionId = this.flags.versionId ?? config.versionId;
+    const unlock = this.flags.lock ?? config.lock ?? "user";
+    const amend = config.sandbox || this.flags.amend;
+    if (config.sandbox) {
+      this.log(`\u{1F514} Application is in Sandbox mode, running deploy in amend mode`);
+    }
+    await deploy({
+      command: this,
+      root: this.flags.root,
+      manifest: this.flags.manifest,
+      output: this.flags.output,
+      versionId,
+      currentVersionId: amend ? versionId : void 0,
+      previousVersionId: amend ? void 0 : versionId,
+      amend,
+      lock: unlock,
+      start: this.flags.start,
+      impersonate: this.flags.impersonate
+    });
+    if (!amend) {
+      this.log(`\u{1F514} You deployed a full version update and are now in Sandbox mode, future deploys will amend`);
+      await sandbox({
+        command: this,
+        isSandboxed: true
+      });
+    }
+    if (!this.flags["no-watch"]) {
+      this.log("\n\u{1F4CA} Watching deployment status...\n");
+      await watchStatus({
+        command: this,
+        root: this.flags.root,
+        manifest: this.flags.manifest,
+        output: "watch",
+        impersonate: this.flags.impersonate
+      });
+    }
+  }
+};
+export {
+  Deploy as default
+};

package/bundle/commands/build/env/get.js

@@ -0,0 +1,105 @@
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/build/env/get.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Get = class extends BaseCommand {
+  static args = {
+    var: import_core.Args.string({ char: "v", description: "env var/secret name", required: true })
+  };
+  static description = "get an env var/secret";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> my-app:env:MY_VAR
+sets an env var/secret.
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({ char: "o", description: "output format", default: "table" }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest"
+    }),
+    versionId: import_core.Flags.string({
+      char: "v",
+      aliases: ["version"],
+      description: "version ID",
+      required: false
+    }),
+    application: import_core.Flags.string({
+      char: "a",
+      description: "application",
+      required: false
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    })
+  };
+  async run() {
+    const apps = await this.loadManifest();
+    const app = apps.find((app2) => valueOf(app2.name) === this.flags.application) || apps[0];
+    if (app === void 0) {
+      this.error(`application ${this.flags.application} not found in manifest`, { exit: 1 });
+    }
+    let isSecret = false;
+    const path = this.args.var.split(":");
+    const envVarName = path.pop();
+    if (envVarName === void 0) {
+      this.error("variable name not specified", { exit: 1 });
+    }
+    if (path.length == 1) {
+      const envStanza = app.env.find((env) => valueOf(env.name) === envVarName);
+      if (envStanza === void 0) {
+        this.error(`variable ${envVarName} not found in manifest`, { exit: 1 });
+      }
+      isSecret = envStanza.secret && valueOf(envStanza.secret) || false;
+    } else if (path.length > 1) {
+      const scriptModules = app.handlers();
+      const scriptModule = scriptModules.find((module) => valueOf(module.name) === path[0]);
+      if (scriptModule === void 0) {
+        this.error(`script module ${path[0]} not found in manifest`, { exit: 1 });
+      }
+      const envStanza = scriptModule.env.find((env) => valueOf(env.name) === envVarName);
+      if (envStanza === void 0) {
+        this.error(`variable ${envVarName} not found in manifest`, { exit: 1 });
+      }
+      isSecret = envStanza.secret && valueOf(envStanza.secret) || false;
+    } else {
+      this.error("variable must be an env variable or secret", { exit: 1 });
+    }
+    const config = await this.loadConfig();
+    const { client: catalogService, userId, organizationId } = await this.catalogService();
+    const resp = await catalogService.getEnvs({
+      userId,
+      organizationId: this.flags.impersonate ?? organizationId,
+      envs: [
+        {
+          applicationName: valueOf(app.name),
+          currentVersionId: this.flags.versionId || config.versionId || "",
+          key: this.args.var
+        }
+      ]
+    });
+    if (isSecret) {
+      console.log(`${this.args.var}=[hash: ${resp.envs[0]?.value}]`);
+    } else {
+      console.log(`${this.args.var}=${resp.envs[0]?.value}`);
+    }
+  }
+};
+export {
+  Get as default
+};

package/bundle/commands/build/env/set.js

@@ -0,0 +1,115 @@
+import {
+  BaseCommand
+} from "../../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../../chunk-G6NE675D.js";
+
+// src/commands/build/env/set.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Set = class extends BaseCommand {
+  static args = {
+    var: import_core.Args.string({ char: "v", description: "env var/secret name", required: true }),
+    value: import_core.Args.string({ char: "V", description: "env var/secret value", required: false })
+  };
+  static description = "set an env var/secret";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> .
+sets an env var/secret.
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    root: import_core.Flags.string({ char: "r", description: "root directory", required: false, default: process.cwd() }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest"
+    }),
+    output: import_core.Flags.string({ char: "o", description: "output format", default: "table" }),
+    versionId: import_core.Flags.string({
+      char: "v",
+      aliases: ["version"],
+      description: "version ID",
+      required: false
+    }),
+    application: import_core.Flags.string({
+      char: "a",
+      description: "application to start",
+      required: false
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    })
+  };
+  async run() {
+    const apps = await this.loadManifest();
+    const app = apps.find((app2) => valueOf(app2.name) === this.flags.application) || apps[0];
+    if (app === void 0) {
+      this.error(`application ${this.flags.application} not found in manifest`, { exit: 1 });
+    }
+    const { client: catalogService, organizationId: defaultOrganizationId, userId } = await this.catalogService();
+    const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+    let isSecret = false;
+    const path = this.args.var.split(":");
+    const envVarName = path.pop();
+    if (envVarName === void 0) {
+      this.error("variable name not specified", { exit: 1 });
+    }
+    if (path.length == 1) {
+      const envStanza = app.env.find((env) => valueOf(env.name) === envVarName);
+      if (envStanza === void 0) {
+        this.error(`variable ${envVarName} not found in manifest`, { exit: 1 });
+      }
+      isSecret = envStanza.secret && valueOf(envStanza.secret) || false;
+    } else if (path.length > 1) {
+      const scriptModules = app.handlers();
+      const scriptModule = scriptModules.find((module) => valueOf(module.name) === path[0]);
+      if (scriptModule === void 0) {
+        this.error(`script module ${path[0]} not found in manifest`, { exit: 1 });
+      }
+      const envStanza = scriptModule.env.find((env) => valueOf(env.name) === envVarName);
+      if (envStanza === void 0) {
+        this.error(`variable ${envVarName} not found in manifest`, { exit: 1 });
+      }
+      isSecret = envStanza.secret && valueOf(envStanza.secret) || false;
+    } else {
+      this.error("variable must be an env variable or secret", { exit: 1 });
+    }
+    let secretValue = this.args.value;
+    if (secretValue === "-") {
+      this.log("reading stdin (ctrl+D to finish)...");
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      secretValue = Buffer.concat(chunks).toString("utf8");
+    }
+    const config = await this.loadConfig();
+    await catalogService.setEnvs({
+      userId,
+      organizationId,
+      envs: [
+        {
+          applicationName: valueOf(app.name),
+          currentVersionId: this.flags.versionId || config.versionId || "",
+          key: this.args.var,
+          value: secretValue || "",
+          isSecret
+        }
+      ]
+    });
+    console.log(`set ${this.args.var}`);
+  }
+};
+export {
+  Set as default
+};