gigadrive 2.4.4 → 2.5.1

package/README.md

@@ -1 +1,23 @@
-# @gigadrive/network-cli
+# Gigadrive CLI
+
+Deploy a supported framework from its project directory without a Gigadrive
+configuration file:
+
+```bash
+pnpm dlx gigadrive login
+pnpm dlx gigadrive deploy
+```
+
+For an unlinked project, `deploy` selects the authenticated user's organization,
+creates a Network application, saves the local `.gigadrive/project.json` link,
+auto-detects the framework, and deploys it. Use `--org` when the user belongs to
+multiple organizations and a non-interactive deployment must select one.
+
+Applications can also be created independently:
+
+```bash
+pnpm dlx gigadrive apps create --org <organization-id> --name <application-name>
+```
+
+The legacy `gigadrive platform deploy` command remains available as an alias for
+`gigadrive deploy`.

package/dist/index.cjs

@@ -32,7 +32,7 @@ var import_effect29 = require("effect");
 // package.json
 var package_default = {
   name: "gigadrive",
-  version: "2.4.4",
+  version: "2.5.1",
   repository: {
     type: "git",
     url: "https://github.com/Gigadrive/sdk.git",
@@ -177,6 +177,13 @@ var ApplicationNotFoundError = class extends import_effect.Schema.TaggedError()(
   }
 ) {
 };
+var NoOrganizationsFoundError = class extends import_effect.Schema.TaggedError()(
+  "NoOrganizationsFoundError",
+  {
+    message: import_effect.Schema.String
+  }
+) {
+};
 var EnvFileReadError = class extends import_effect.Schema.TaggedError()("EnvFileReadError", {
   message: import_effect.Schema.String,
   cause: import_effect.Schema.optional(import_effect.Schema.String)
@@ -513,8 +520,11 @@ var CLI_SCOPES = [
   "openid",
   "profile",
   "email",
+  // Platform discovery used for zero-config application onboarding
+  "platform:organizations:read",
   // Network API capabilities
   "network:applications:read",
+  "network:applications:write",
   "network:env_vars:read",
   "network:env_vars:write",
   "network:env_vars:delete",
@@ -523,11 +533,6 @@ var CLI_SCOPES = [
   "network:deployments:trigger",
   "network:ai_gateway:chat",
   "network:ai_gateway:models",
-  "network:ai_gateway:usage:read",
-  "network:ai_gateway:budgets:read",
-  "network:ai_gateway:budgets:write",
-  "network:ai_gateway:policies:read",
-  "network:ai_gateway:policies:write",
   // Provisioning local-dev API credentials
   "platform:api_keys:read",
   "platform:api_keys:write",
@@ -1106,13 +1111,13 @@ var readStdin = import_effect8.Effect.async((resume) => {
   stdin.resume();
 });
 var readJsonInput = (file) => import_effect8.Effect.gen(function* () {
-  const path = import_effect8.Option.getOrUndefined(file);
+  const path2 = import_effect8.Option.getOrUndefined(file);
   let raw;
-  if (path === void 0 || path === "-") {
+  if (path2 === void 0 || path2 === "-") {
     raw = yield* readStdin;
   } else {
     const fs = yield* import_platform3.FileSystem.FileSystem;
-    raw = yield* fs.readFileString(path, "utf8").pipe(import_effect8.Effect.mapError((e) => new ApiRequestError({ message: `Failed to read ${path}: ${String(e)}` })));
+    raw = yield* fs.readFileString(path2, "utf8").pipe(import_effect8.Effect.mapError((e) => new ApiRequestError({ message: `Failed to read ${path2}: ${String(e)}` })));
   }
   return yield* import_effect8.Effect.try({
     try: () => JSON.parse(raw),
@@ -1332,14 +1337,30 @@ var aiCommand = aiBase.pipe(
 // src/commands/apps/index.ts
 var import_cli2 = require("@effect/cli");
 var import_effect9 = require("effect");
-var orgOption2 = import_cli2.Options.text("org").pipe(
+var listOrgOption = import_cli2.Options.text("org").pipe(
   import_cli2.Options.withAlias("o"),
   import_cli2.Options.withDescription("Only list applications belonging to this organization ID"),
   import_cli2.Options.optional
 );
+var createOrgOption = import_cli2.Options.text("org").pipe(
+  import_cli2.Options.withAlias("o"),
+  import_cli2.Options.withDescription("Organization ID that will own the application")
+);
+var nameOption = import_cli2.Options.text("name").pipe(
+  import_cli2.Options.withAlias("n"),
+  import_cli2.Options.withDescription("Application display name")
+);
+var slugOption = import_cli2.Options.text("slug").pipe(
+  import_cli2.Options.withDescription("Optional lowercase application slug"),
+  import_cli2.Options.optional
+);
+var rootDirectoryOption = import_cli2.Options.text("root-directory").pipe(
+  import_cli2.Options.withDescription("Optional project directory relative to the repository root"),
+  import_cli2.Options.optional
+);
 var appsListCommand = import_cli2.Command.make(
   "list",
-  { org: orgOption2 },
+  { org: listOrgOption },
   ({ org }) => import_effect9.Effect.gen(function* () {
     const apiClient = yield* ApiClientService;
     const organizationId = import_effect9.Option.getOrUndefined(org);
@@ -1362,8 +1383,35 @@ ${total} application(s).`);
     })
   )
 );
+var appsCreateCommand = import_cli2.Command.make(
+  "create",
+  { org: createOrgOption, name: nameOption, slug: slugOption, rootDirectory: rootDirectoryOption },
+  ({ org, name, slug, rootDirectory }) => import_effect9.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const application = yield* apiClient.request(
+      (client) => client.applications.create({
+        organizationId: org,
+        name,
+        ...import_effect9.Option.match(slug, { onNone: () => ({}), onSome: (value) => ({ slug: value }) }),
+        ...import_effect9.Option.match(rootDirectory, {
+          onNone: () => ({}),
+          onSome: (value) => ({ rootDirectory: value })
+        })
+      })
+    );
+    yield* import_effect9.Console.log(`Created application ${application.name} (${application.id}).`);
+    yield* import_effect9.Console.log(`Run "gigadrive link --app ${application.id}" to link the current directory.`);
+  }).pipe(
+    import_effect9.Effect.catchTags({
+      NotAuthenticatedError: (err) => import_effect9.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect9.Effect.andThen(import_effect9.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect9.Console.error(`Failed to create application: ${err.message}`).pipe(import_effect9.Effect.andThen(import_effect9.Effect.fail(err)))
+    })
+  )
+);
 var appsBase = import_cli2.Command.make("apps", {}, () => import_effect9.Effect.void);
-var appsCommand = appsBase.pipe(import_cli2.Command.withSubcommands([appsListCommand]));
+var appsCommand = appsBase.pipe(import_cli2.Command.withSubcommands([appsListCommand, appsCreateCommand]));
 
 // src/commands/build/index.ts
 var import_cli3 = require("@effect/cli");
@@ -1651,7 +1699,7 @@ var appOption2 = import_cli6.Options.text("app").pipe(
   import_cli6.Options.withDescription("Filter by application ID (defaults to the linked application)"),
   import_cli6.Options.optional
 );
-var orgOption3 = import_cli6.Options.text("org").pipe(
+var orgOption2 = import_cli6.Options.text("org").pipe(
   import_cli6.Options.withAlias("o"),
   import_cli6.Options.withDescription("Filter by organization ID"),
   import_cli6.Options.optional
@@ -1671,7 +1719,7 @@ var resolveApplicationFilter = (app) => import_effect15.Option.match(app, {
 });
 var deploymentsListCommand = import_cli6.Command.make(
   "list",
-  { app: appOption2, org: orgOption3, status: statusOption },
+  { app: appOption2, org: orgOption2, status: statusOption },
   ({ app, org, status }) => import_effect15.Effect.gen(function* () {
     const apiClient = yield* ApiClientService;
     const applicationId = yield* resolveApplicationFilter(app);
@@ -1965,7 +2013,7 @@ var appOption3 = import_cli7.Options.text("app").pipe(
   import_cli7.Options.withDescription("Operate on this application (overrides the linked application)"),
   import_cli7.Options.optional
 );
-var orgOption4 = import_cli7.Options.text("org").pipe(
+var orgOption3 = import_cli7.Options.text("org").pipe(
   import_cli7.Options.withAlias("o"),
   import_cli7.Options.withDescription("Operate on this organization instead of an application"),
   import_cli7.Options.optional
@@ -2014,7 +2062,7 @@ var resolveScope = (app, org) => import_effect19.Effect.gen(function* () {
 });
 var envListCommand = import_cli7.Command.make(
   "list",
-  { app: appOption3, org: orgOption4 },
+  { app: appOption3, org: orgOption3 },
   ({ app, org }) => import_effect19.Effect.gen(function* () {
     const apiClient = yield* ApiClientService;
     const scope = yield* resolveScope(app, org);
@@ -2041,7 +2089,7 @@ var envListCommand = import_cli7.Command.make(
 );
 var envSetCommand = import_cli7.Command.make(
   "set",
-  { keyValue: keyValueArg, app: appOption3, org: orgOption4, sensitive: sensitiveOption, env: envIdOption },
+  { keyValue: keyValueArg, app: appOption3, org: orgOption3, sensitive: sensitiveOption, env: envIdOption },
   ({ keyValue, app, org, sensitive, env }) => import_effect19.Effect.gen(function* () {
     const separator = keyValue.indexOf("=");
     if (separator <= 0) {
@@ -2074,7 +2122,7 @@ var envSetCommand = import_cli7.Command.make(
 );
 var envRmCommand = import_cli7.Command.make(
   "rm",
-  { keyOrId: keyOrIdArg, app: appOption3, org: orgOption4 },
+  { keyOrId: keyOrIdArg, app: appOption3, org: orgOption3 },
   ({ keyOrId, app, org }) => import_effect19.Effect.gen(function* () {
     const apiClient = yield* ApiClientService;
     const scope = yield* resolveScope(app, org);
@@ -2188,14 +2236,14 @@ var appOption4 = import_cli8.Options.text("app").pipe(
   import_cli8.Options.withDescription("Application ID to link (skips the interactive picker)"),
   import_cli8.Options.optional
 );
-var orgOption5 = import_cli8.Options.text("org").pipe(
+var orgOption4 = import_cli8.Options.text("org").pipe(
   import_cli8.Options.withAlias("o"),
   import_cli8.Options.withDescription("Only list applications belonging to this organization ID"),
   import_cli8.Options.optional
 );
 var linkCommand = import_cli8.Command.make(
   "link",
-  { app: appOption4, org: orgOption5 },
+  { app: appOption4, org: orgOption4 },
   ({ app, org }) => import_effect20.Effect.gen(function* () {
     const apiClient = yield* ApiClientService;
     const projectLink = yield* ProjectLinkService;
@@ -2320,6 +2368,7 @@ var import_platform9 = require("@effect/platform");
 var import_commons = require("@gigadrive/commons");
 var import_effect25 = require("effect");
 var os4 = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
 
 // src/services/archive.ts
 var import_platform8 = require("@effect/platform");
@@ -2329,7 +2378,15 @@ var import_effect23 = require("effect");
 var import_ignore = __toESM(require("ignore"), 1);
 var nodeFs = __toESM(require("fs"), 1);
 var nodeFsPromises = __toESM(require("fs/promises"), 1);
-var IGNORE_FILE_NAMES = [".gigadriveignore", ".vercelignore", ".dockerignore", ".nowignore"];
+var IGNORE_FILE_NAMES = [".gitignore", ".dockerignore", ".nowignore", ".vercelignore", ".gigadriveignore"];
+var MANAGED_IGNORE_PATTERNS = [
+  ".git/",
+  "**/.git/",
+  "node_modules/",
+  "**/node_modules/",
+  "**/.DS_Store",
+  "**/Thumbs.db"
+];
 var readIgnoreFile = (fs, ignorePath) => fs.readFileString(ignorePath, "utf8").pipe(
   import_effect23.Effect.map((content) => content.split("\n").filter((line) => line.trim() !== "")),
   import_effect23.Effect.catchAll(() => import_effect23.Effect.succeed([]))
@@ -2360,19 +2417,23 @@ var collectIgnorePatterns = (fs, pathService, dir, baseDir, ignoreRules) => impo
     }
   }
 }).pipe(import_effect23.Effect.catchAll(() => import_effect23.Effect.void));
-var initializeIgnoreRules = (fs, pathService, baseDir) => import_effect23.Effect.gen(function* () {
+var initializeIgnoreRules = (fs, pathService, baseDir, useIgnoreFiles, useManagedIgnore) => import_effect23.Effect.gen(function* () {
   const ignoreRules = (0, import_ignore.default)();
-  ignoreRules.add([".git/", "**/.DS_Store", "**/Thumbs.db"]);
-  for (const ignoreFileName of IGNORE_FILE_NAMES) {
-    const ignoreFilePath = pathService.join(baseDir, ignoreFileName);
-    const patterns = yield* readIgnoreFile(fs, ignoreFilePath);
-    if (patterns.length > 0) {
-      ignoreRules.add(
-        patterns.map((pattern) => pattern.startsWith("!") ? `!${pattern.slice(1)}` : pattern)
-      );
+  if (useManagedIgnore) {
+    ignoreRules.add(MANAGED_IGNORE_PATTERNS);
+  }
+  if (useIgnoreFiles) {
+    for (const ignoreFileName of IGNORE_FILE_NAMES) {
+      const ignoreFilePath = pathService.join(baseDir, ignoreFileName);
+      const patterns = yield* readIgnoreFile(fs, ignoreFilePath);
+      if (patterns.length > 0) {
+        ignoreRules.add(
+          patterns.map((pattern) => pattern.startsWith("!") ? `!${pattern.slice(1)}` : pattern)
+        );
+      }
     }
+    yield* collectIgnorePatterns(fs, pathService, baseDir, baseDir, ignoreRules);
   }
-  yield* collectIgnorePatterns(fs, pathService, baseDir, baseDir, ignoreRules);
   return ignoreRules;
 });
 var getFilesToInclude = (fs, pathService, dir, ignoreRules) => import_effect23.Effect.gen(function* () {
@@ -2409,7 +2470,13 @@ var ArchiveService = class extends import_effect23.Effect.Service()("ArchiveServ
       yield* import_effect23.Effect.annotateCurrentSpan("inputDir", inputDir);
       yield* import_effect23.Effect.annotateCurrentSpan("outputFile", outputFile);
       yield* import_effect23.Effect.log("Creating zip archive", { inputDir, outputFile });
-      const ignoreRules = options.useIgnoreFiles !== false ? yield* initializeIgnoreRules(fs, pathService, inputDir) : (0, import_ignore.default)();
+      const ignoreRules = yield* initializeIgnoreRules(
+        fs,
+        pathService,
+        inputDir,
+        options.useIgnoreFiles !== false,
+        options.useManagedIgnore !== false
+      );
       const filesToInclude = options.whitelist ? yield* import_effect23.Effect.tryPromise({
         try: () => Promise.all(
           options.whitelist.map((file) => (0, import_build_utils3.getFilesForPattern)(file, inputDir, options.excludeFiles ?? []))
@@ -2590,22 +2657,83 @@ var appOption5 = import_cli11.Options.text("app").pipe(
   import_cli11.Options.withDescription("Application ID to deploy to (overrides the linked application)"),
   import_cli11.Options.optional
 );
+var orgOption5 = import_cli11.Options.text("org").pipe(
+  import_cli11.Options.withAlias("o"),
+  import_cli11.Options.withDescription("Organization ID to use when automatically creating an application"),
+  import_cli11.Options.optional
+);
+var nameOption2 = import_cli11.Options.text("name").pipe(
+  import_cli11.Options.withAlias("n"),
+  import_cli11.Options.withDescription("Application name to use when automatically creating an application"),
+  import_cli11.Options.optional
+);
+var createAndLinkDeploymentApplication = (input) => import_effect25.Effect.gen(function* () {
+  const projectLink = yield* ProjectLinkService;
+  const apiClient = yield* ApiClientService;
+  const { items: organizations } = yield* apiClient.request((client) => client.organizations.list());
+  const availableOrganizations = import_effect25.Option.match(input.org, {
+    onNone: () => organizations,
+    onSome: (organizationId) => organizations.filter((organization2) => organization2.id === organizationId)
+  });
+  if (availableOrganizations.length === 0) {
+    return yield* new NoOrganizationsFoundError({
+      message: import_effect25.Option.match(input.org, {
+        onNone: () => 'No organization is available for this deployment. Create an organization, then run "gigadrive deploy" again.',
+        onSome: (organizationId) => `Organization "${organizationId}" was not found among your organizations.`
+      })
+    });
+  }
+  const organization = availableOrganizations.length === 1 ? availableOrganizations[0] : yield* import_cli11.Prompt.run(
+    import_cli11.Prompt.select({
+      message: "Select an organization for this application",
+      choices: availableOrganizations.map((candidate) => ({
+        title: candidate.name,
+        value: candidate
+      }))
+    })
+  );
+  const inferredName = path.basename(input.cwd) || "Application";
+  const applicationName = import_effect25.Option.match(input.name, {
+    onNone: () => inferredName,
+    onSome: (name) => name
+  }).trim();
+  const application = yield* apiClient.request(
+    (client) => client.applications.create({
+      organizationId: organization.id,
+      name: applicationName || inferredName
+    })
+  );
+  yield* projectLink.save(input.cwd, {
+    applicationId: application.id,
+    organizationId: organization.id
+  });
+  yield* import_effect25.Console.log(`Created and linked application ${application.name} (${application.id}).`);
+  return application.id;
+});
+var resolveLinkedDeploymentApplication = (input) => import_effect25.Effect.gen(function* () {
+  const projectLink = yield* ProjectLinkService;
+  const existingLink = yield* projectLink.load(input.cwd);
+  return yield* import_effect25.Option.match(existingLink, {
+    onNone: () => createAndLinkDeploymentApplication(input),
+    onSome: (link) => import_effect25.Effect.succeed(link.applicationId)
+  });
+});
+var resolveDeploymentApplication = (input) => import_effect25.Option.match(input.app, {
+  onNone: () => resolveLinkedDeploymentApplication(input),
+  onSome: import_effect25.Effect.succeed
+});
 var deployCommand = import_cli11.Command.make(
   "deploy",
-  { app: appOption5 },
-  ({ app }) => import_effect25.Effect.gen(function* () {
+  { app: appOption5, org: orgOption5, name: nameOption2 },
+  ({ app, org, name }) => import_effect25.Effect.gen(function* () {
     const projectConfig = yield* ProjectConfigService;
     const deploymentApi = yield* DeploymentApiService;
     const archiveService = yield* ArchiveService;
-    const projectLink = yield* ProjectLinkService;
     const pathService = yield* import_platform9.Path.Path;
     const cwd = process.cwd();
-    const applicationId = yield* import_effect25.Option.match(app, {
-      onSome: (id) => import_effect25.Effect.succeed(id),
-      onNone: () => projectLink.resolve(cwd).pipe(import_effect25.Effect.map((link) => link.applicationId))
-    });
     yield* import_effect25.Effect.log("Starting deploy command");
     const { config } = yield* projectConfig.resolve(cwd);
+    const applicationId = yield* resolveDeploymentApplication({ app, org, name, cwd });
     yield* import_effect25.Console.log("Creating deployment...");
     const deploymentId = yield* deploymentApi.createDeployment(applicationId);
     yield* import_effect25.Console.log(`Deployment ID: ${deploymentId}`);
@@ -2613,9 +2741,7 @@ var deployCommand = import_cli11.Command.make(
     const archivePath = pathService.join(os4.tmpdir(), `project-${Date.now()}.zip`);
     const archive = yield* archiveService.createZipArchive(config.userArchive?.rootOverwrite || cwd, archivePath, {
       whitelist: config.userArchive?.fileWhitelist,
-      excludeFiles: config.excludeFiles,
-      useIgnoreFiles: false,
-      useManagedIgnore: false
+      excludeFiles: config.excludeFiles
     });
     yield* import_effect25.Console.log(`Archive created (${(0, import_commons.formatFileSize)(archive.size)})`);
     yield* import_effect25.Console.log("Uploading archive...");
@@ -2625,8 +2751,14 @@ var deployCommand = import_cli11.Command.make(
     yield* pollDeployment(deploymentId);
   }).pipe(
     import_effect25.Effect.catchTags({
-      ProjectNotLinkedError: (err) => import_effect25.Console.error(err.message).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      QuitException: () => import_effect25.Console.log("Cancelled."),
+      NotAuthenticatedError: (err) => import_effect25.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect25.Effect.andThen(import_effect25.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect25.Console.error(`Application setup failed: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      NoOrganizationsFoundError: (err) => import_effect25.Console.error(err.message).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
       ProjectLinkReadError: (err) => import_effect25.Console.error(err.message).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      ProjectLinkWriteError: (err) => import_effect25.Console.error(err.message).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
       ConfigNotFoundError: (err) => import_effect25.Console.error(err.message).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
       ConfigParseError: (err) => import_effect25.Console.error(`Config parse error: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
       ConfigValidationError: (err) => import_effect25.Effect.gen(function* () {
@@ -2917,6 +3049,7 @@ var gigadrive = import_cli15.Command.make("gigadrive", {}, () => import_effect29
     aiCommand,
     buildCommand,
     debugCommand,
+    deployCommand,
     platformCommand,
     setupCommand
   ])