gigadrive 2.4.4 → 2.5.0

package/dist/index.mjs

@@ -9,7 +9,7 @@ import { Effect as Effect27, Layer, LogLevel, Logger } from "effect";
 // package.json
 var package_default = {
   name: "gigadrive",
-  version: "2.4.4",
+  version: "2.5.0",
   repository: {
     type: "git",
     url: "https://github.com/Gigadrive/sdk.git",
@@ -154,6 +154,13 @@ var ApplicationNotFoundError = class extends Schema.TaggedError()(
   }
 ) {
 };
+var NoOrganizationsFoundError = class extends Schema.TaggedError()(
+  "NoOrganizationsFoundError",
+  {
+    message: Schema.String
+  }
+) {
+};
 var EnvFileReadError = class extends Schema.TaggedError()("EnvFileReadError", {
   message: Schema.String,
   cause: Schema.optional(Schema.String)
@@ -490,8 +497,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",
@@ -1083,13 +1093,13 @@ var readStdin = Effect6.async((resume) => {
   stdin.resume();
 });
 var readJsonInput = (file) => Effect6.gen(function* () {
-  const path = Option4.getOrUndefined(file);
+  const path2 = Option4.getOrUndefined(file);
   let raw;
-  if (path === void 0 || path === "-") {
+  if (path2 === void 0 || path2 === "-") {
     raw = yield* readStdin;
   } else {
     const fs = yield* FileSystem3.FileSystem;
-    raw = yield* fs.readFileString(path, "utf8").pipe(Effect6.mapError((e) => new ApiRequestError({ message: `Failed to read ${path}: ${String(e)}` })));
+    raw = yield* fs.readFileString(path2, "utf8").pipe(Effect6.mapError((e) => new ApiRequestError({ message: `Failed to read ${path2}: ${String(e)}` })));
   }
   return yield* Effect6.try({
     try: () => JSON.parse(raw),
@@ -1309,14 +1319,30 @@ var aiCommand = aiBase.pipe(
 // src/commands/apps/index.ts
 import { Command as Command2, Options as Options2 } from "@effect/cli";
 import { Console as Console3, Effect as Effect7, Option as Option5 } from "effect";
-var orgOption2 = Options2.text("org").pipe(
+var listOrgOption = Options2.text("org").pipe(
   Options2.withAlias("o"),
   Options2.withDescription("Only list applications belonging to this organization ID"),
   Options2.optional
 );
+var createOrgOption = Options2.text("org").pipe(
+  Options2.withAlias("o"),
+  Options2.withDescription("Organization ID that will own the application")
+);
+var nameOption = Options2.text("name").pipe(
+  Options2.withAlias("n"),
+  Options2.withDescription("Application display name")
+);
+var slugOption = Options2.text("slug").pipe(
+  Options2.withDescription("Optional lowercase application slug"),
+  Options2.optional
+);
+var rootDirectoryOption = Options2.text("root-directory").pipe(
+  Options2.withDescription("Optional project directory relative to the repository root"),
+  Options2.optional
+);
 var appsListCommand = Command2.make(
   "list",
-  { org: orgOption2 },
+  { org: listOrgOption },
   ({ org }) => Effect7.gen(function* () {
     const apiClient = yield* ApiClientService;
     const organizationId = Option5.getOrUndefined(org);
@@ -1339,8 +1365,35 @@ ${total} application(s).`);
     })
   )
 );
+var appsCreateCommand = Command2.make(
+  "create",
+  { org: createOrgOption, name: nameOption, slug: slugOption, rootDirectory: rootDirectoryOption },
+  ({ org, name, slug, rootDirectory }) => Effect7.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const application = yield* apiClient.request(
+      (client) => client.applications.create({
+        organizationId: org,
+        name,
+        ...Option5.match(slug, { onNone: () => ({}), onSome: (value) => ({ slug: value }) }),
+        ...Option5.match(rootDirectory, {
+          onNone: () => ({}),
+          onSome: (value) => ({ rootDirectory: value })
+        })
+      })
+    );
+    yield* Console3.log(`Created application ${application.name} (${application.id}).`);
+    yield* Console3.log(`Run "gigadrive link --app ${application.id}" to link the current directory.`);
+  }).pipe(
+    Effect7.catchTags({
+      NotAuthenticatedError: (err) => Console3.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        Effect7.andThen(Effect7.fail(err))
+      ),
+      ApiRequestError: (err) => Console3.error(`Failed to create application: ${err.message}`).pipe(Effect7.andThen(Effect7.fail(err)))
+    })
+  )
+);
 var appsBase = Command2.make("apps", {}, () => Effect7.void);
-var appsCommand = appsBase.pipe(Command2.withSubcommands([appsListCommand]));
+var appsCommand = appsBase.pipe(Command2.withSubcommands([appsListCommand, appsCreateCommand]));
 
 // src/commands/build/index.ts
 import { Command as Command3 } from "@effect/cli";
@@ -1636,7 +1689,7 @@ var appOption2 = Options3.text("app").pipe(
   Options3.withDescription("Filter by application ID (defaults to the linked application)"),
   Options3.optional
 );
-var orgOption3 = Options3.text("org").pipe(
+var orgOption2 = Options3.text("org").pipe(
   Options3.withAlias("o"),
   Options3.withDescription("Filter by organization ID"),
   Options3.optional
@@ -1656,7 +1709,7 @@ var resolveApplicationFilter = (app) => Option6.match(app, {
 });
 var deploymentsListCommand = Command6.make(
   "list",
-  { app: appOption2, org: orgOption3, status: statusOption },
+  { app: appOption2, org: orgOption2, status: statusOption },
   ({ app, org, status }) => Effect13.gen(function* () {
     const apiClient = yield* ApiClientService;
     const applicationId = yield* resolveApplicationFilter(app);
@@ -1950,7 +2003,7 @@ var appOption3 = Options4.text("app").pipe(
   Options4.withDescription("Operate on this application (overrides the linked application)"),
   Options4.optional
 );
-var orgOption4 = Options4.text("org").pipe(
+var orgOption3 = Options4.text("org").pipe(
   Options4.withAlias("o"),
   Options4.withDescription("Operate on this organization instead of an application"),
   Options4.optional
@@ -1999,7 +2052,7 @@ var resolveScope = (app, org) => Effect17.gen(function* () {
 });
 var envListCommand = Command7.make(
   "list",
-  { app: appOption3, org: orgOption4 },
+  { app: appOption3, org: orgOption3 },
   ({ app, org }) => Effect17.gen(function* () {
     const apiClient = yield* ApiClientService;
     const scope = yield* resolveScope(app, org);
@@ -2026,7 +2079,7 @@ var envListCommand = Command7.make(
 );
 var envSetCommand = Command7.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 }) => Effect17.gen(function* () {
     const separator = keyValue.indexOf("=");
     if (separator <= 0) {
@@ -2059,7 +2112,7 @@ var envSetCommand = Command7.make(
 );
 var envRmCommand = Command7.make(
   "rm",
-  { keyOrId: keyOrIdArg, app: appOption3, org: orgOption4 },
+  { keyOrId: keyOrIdArg, app: appOption3, org: orgOption3 },
   ({ keyOrId, app, org }) => Effect17.gen(function* () {
     const apiClient = yield* ApiClientService;
     const scope = yield* resolveScope(app, org);
@@ -2173,14 +2226,14 @@ var appOption4 = Options5.text("app").pipe(
   Options5.withDescription("Application ID to link (skips the interactive picker)"),
   Options5.optional
 );
-var orgOption5 = Options5.text("org").pipe(
+var orgOption4 = Options5.text("org").pipe(
   Options5.withAlias("o"),
   Options5.withDescription("Only list applications belonging to this organization ID"),
   Options5.optional
 );
 var linkCommand = Command8.make(
   "link",
-  { app: appOption4, org: orgOption5 },
+  { app: appOption4, org: orgOption4 },
   ({ app, org }) => Effect18.gen(function* () {
     const apiClient = yield* ApiClientService;
     const projectLink = yield* ProjectLinkService;
@@ -2300,11 +2353,12 @@ import { Command as Command12 } from "@effect/cli";
 import { Effect as Effect24 } from "effect";
 
 // src/commands/platform/deploy/index.ts
-import { Command as Command11, Options as Options6 } from "@effect/cli";
+import { Command as Command11, Options as Options6, Prompt as Prompt3 } from "@effect/cli";
 import { FileSystem as FileSystem9, Path as Path8 } from "@effect/platform";
 import { formatFileSize } from "@gigadrive/commons";
 import { Console as Console11, Duration as Duration2, Effect as Effect23, Option as Option12, Schedule, Stream } from "effect";
 import * as os4 from "os";
+import * as path from "path";
 
 // src/services/archive.ts
 import { FileSystem as FileSystem8, Path as Path7 } from "@effect/platform";
@@ -2575,22 +2629,83 @@ var appOption5 = Options6.text("app").pipe(
   Options6.withDescription("Application ID to deploy to (overrides the linked application)"),
   Options6.optional
 );
+var orgOption5 = Options6.text("org").pipe(
+  Options6.withAlias("o"),
+  Options6.withDescription("Organization ID to use when automatically creating an application"),
+  Options6.optional
+);
+var nameOption2 = Options6.text("name").pipe(
+  Options6.withAlias("n"),
+  Options6.withDescription("Application name to use when automatically creating an application"),
+  Options6.optional
+);
+var createAndLinkDeploymentApplication = (input) => Effect23.gen(function* () {
+  const projectLink = yield* ProjectLinkService;
+  const apiClient = yield* ApiClientService;
+  const { items: organizations } = yield* apiClient.request((client) => client.organizations.list());
+  const availableOrganizations = Option12.match(input.org, {
+    onNone: () => organizations,
+    onSome: (organizationId) => organizations.filter((organization2) => organization2.id === organizationId)
+  });
+  if (availableOrganizations.length === 0) {
+    return yield* new NoOrganizationsFoundError({
+      message: Option12.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* Prompt3.run(
+    Prompt3.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 = Option12.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* Console11.log(`Created and linked application ${application.name} (${application.id}).`);
+  return application.id;
+});
+var resolveLinkedDeploymentApplication = (input) => Effect23.gen(function* () {
+  const projectLink = yield* ProjectLinkService;
+  const existingLink = yield* projectLink.load(input.cwd);
+  return yield* Option12.match(existingLink, {
+    onNone: () => createAndLinkDeploymentApplication(input),
+    onSome: (link) => Effect23.succeed(link.applicationId)
+  });
+});
+var resolveDeploymentApplication = (input) => Option12.match(input.app, {
+  onNone: () => resolveLinkedDeploymentApplication(input),
+  onSome: Effect23.succeed
+});
 var deployCommand = Command11.make(
   "deploy",
-  { app: appOption5 },
-  ({ app }) => Effect23.gen(function* () {
+  { app: appOption5, org: orgOption5, name: nameOption2 },
+  ({ app, org, name }) => Effect23.gen(function* () {
     const projectConfig = yield* ProjectConfigService;
     const deploymentApi = yield* DeploymentApiService;
     const archiveService = yield* ArchiveService;
-    const projectLink = yield* ProjectLinkService;
     const pathService = yield* Path8.Path;
     const cwd = process.cwd();
-    const applicationId = yield* Option12.match(app, {
-      onSome: (id) => Effect23.succeed(id),
-      onNone: () => projectLink.resolve(cwd).pipe(Effect23.map((link) => link.applicationId))
-    });
     yield* Effect23.log("Starting deploy command");
     const { config } = yield* projectConfig.resolve(cwd);
+    const applicationId = yield* resolveDeploymentApplication({ app, org, name, cwd });
     yield* Console11.log("Creating deployment...");
     const deploymentId = yield* deploymentApi.createDeployment(applicationId);
     yield* Console11.log(`Deployment ID: ${deploymentId}`);
@@ -2610,8 +2725,14 @@ var deployCommand = Command11.make(
     yield* pollDeployment(deploymentId);
   }).pipe(
     Effect23.catchTags({
-      ProjectNotLinkedError: (err) => Console11.error(err.message).pipe(Effect23.andThen(Effect23.fail(err))),
+      QuitException: () => Console11.log("Cancelled."),
+      NotAuthenticatedError: (err) => Console11.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        Effect23.andThen(Effect23.fail(err))
+      ),
+      ApiRequestError: (err) => Console11.error(`Application setup failed: ${err.message}`).pipe(Effect23.andThen(Effect23.fail(err))),
+      NoOrganizationsFoundError: (err) => Console11.error(err.message).pipe(Effect23.andThen(Effect23.fail(err))),
       ProjectLinkReadError: (err) => Console11.error(err.message).pipe(Effect23.andThen(Effect23.fail(err))),
+      ProjectLinkWriteError: (err) => Console11.error(err.message).pipe(Effect23.andThen(Effect23.fail(err))),
       ConfigNotFoundError: (err) => Console11.error(err.message).pipe(Effect23.andThen(Effect23.fail(err))),
       ConfigParseError: (err) => Console11.error(`Config parse error: ${err.message}`).pipe(Effect23.andThen(Effect23.fail(err))),
       ConfigValidationError: (err) => Effect23.gen(function* () {
@@ -2727,7 +2848,7 @@ var platformBase = Command12.make("platform", {}, () => Effect24.void);
 var platformCommand = platformBase.pipe(Command12.withSubcommands([deployCommand]));
 
 // src/commands/setup/index.ts
-import { Args as Args4, Command as Command13, Options as Options7, Prompt as Prompt3 } from "@effect/cli";
+import { Args as Args4, Command as Command13, Options as Options7, Prompt as Prompt4 } from "@effect/cli";
 import { Console as Console12, Effect as Effect25, Option as Option13 } from "effect";
 var fileArg2 = Args4.text({ name: "file" }).pipe(
   Args4.withDescription("Output file to write (default: .env.local)"),
@@ -2805,8 +2926,8 @@ var setupCommand = Command13.make(
       } else if (apps.length === 1) {
         chosen = apps[0];
       } else {
-        chosen = yield* Prompt3.run(
-          Prompt3.select({
+        chosen = yield* Prompt4.run(
+          Prompt4.select({
             message: "Select an application to set up",
             choices: apps.map((a) => ({ title: `${a.name} (${a.organization.name})`, value: a }))
           })
@@ -2823,8 +2944,8 @@ var setupCommand = Command13.make(
     );
     const existing = yield* envFile.read(target);
     if (Option13.isSome(existing) && !yes) {
-      const overwrite = yield* Prompt3.run(
-        Prompt3.confirm({ message: `${target} already exists. Overwrite?`, initial: false })
+      const overwrite = yield* Prompt4.run(
+        Prompt4.confirm({ message: `${target} already exists. Overwrite?`, initial: false })
       );
       if (!overwrite) {
         return yield* Console12.log("Cancelled.");
@@ -2902,6 +3023,7 @@ var gigadrive = Command15.make("gigadrive", {}, () => Effect27.void).pipe(
     aiCommand,
     buildCommand,
     debugCommand,
+    deployCommand,
     platformCommand,
     setupCommand
   ])