shipthis 0.1.25 → 0.1.26

package/dist/commands/game/details.js

@@ -0,0 +1,113 @@
+import { jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Flags } from '@oclif/core';
+import 'react';
+import '../../index-nnzhQ3nY.js';
+import { c as BaseGameCommand, D as DetailsFlags, t as GameEngine } from '../../index-DkNQs11R.js';
+import 'ink-spinner';
+import 'axios';
+import 'crypto-js';
+import 'uuid';
+import 'fs';
+import 'luxon';
+import '@inkjs/ui';
+import '@tanstack/react-query';
+import 'yazl';
+import { i as isValidSemVer } from '../../index-BB00V5oF.js';
+import 'open';
+import 'marked';
+import 'marked-terminal';
+import 'path';
+import 'qrcode';
+import { S as StatusTable } from '../../StatusTable-Dm5St4g-.js';
+import 'string-length';
+import 'strip-ansi';
+import 'fast-glob';
+import { C as Command } from '../../Command-B3AmRt2w.js';
+import 'socket.io-client';
+import '../../useAndroidServiceAccountTestResult-DcYDam-p.js';
+import '@expo/apple-utils/build/index.js';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import 'isomorphic-git';
+import 'ini';
+import 'deepmerge';
+import '../../Title-BCQtayg6.js';
+
+class GameDetails extends BaseGameCommand {
+  static args = {};
+  static description = "Shows and sets the details of a game.";
+  static examples = [
+    "<%= config.bin %> <%= command.id %>",
+    "<%= config.bin %> <%= command.id %> --gameId 0c179fc4",
+    "<%= config.bin %> <%= command.id %> --buildNumber 5 --semanticVersion 1.2.3",
+    "<%= config.bin %> <%= command.id %> --gameEngine godot --gameEngineVersion 4.2 --force"
+  ];
+  static flags = {
+    ...BaseGameCommand.flags,
+    force: Flags.boolean({ char: "f", description: "Force the command to run" }),
+    ...DetailsFlags
+  };
+  async run() {
+    const { gameId, force, ...valueFlags } = this.flags;
+    const {
+      name,
+      semanticVersion,
+      buildNumber,
+      gameEngine,
+      gameEngineVersion,
+      iosBundleId,
+      androidPackageName,
+      gcpProjectId,
+      gcpServiceAccountId
+    } = valueFlags;
+    if (semanticVersion && !isValidSemVer(semanticVersion))
+      throw new Error(`Invalid semantic version: ${semanticVersion}`);
+    if ((gameEngine || gameEngineVersion || iosBundleId || androidPackageName) && !force)
+      throw new Error("Use --force to set the restricted fields");
+    if (gameEngine && gameEngine !== GameEngine.GODOT) throw new Error(`Game engine ${gameEngine} not supported`);
+    let game = await this.getGame();
+    const update = {
+      name: name || game.name,
+      details: {
+        ...game.details,
+        ...semanticVersion && { semanticVersion },
+        ...buildNumber && { buildNumber },
+        ...gameEngine && { gameEngine },
+        ...gameEngineVersion && { gameEngineVersion },
+        ...iosBundleId && { iosBundleId },
+        ...androidPackageName && { androidPackageName },
+        ...gcpProjectId && { gcpProjectId },
+        ...gcpServiceAccountId && { gcpServiceAccountId }
+      }
+    };
+    if (Object.keys(valueFlags).length > 0) {
+      game = await this.updateGame(update);
+    }
+    render(
+      /* @__PURE__ */ jsx(Command, { command: this, children: /* @__PURE__ */ jsx(
+        StatusTable,
+        {
+          title: "Game Details",
+          statuses: {
+            "Game Name": game.name,
+            "Game Engine": game.details?.gameEngine || "Please set!",
+            "Game Engine Version": game.details?.gameEngineVersion || "Please set!",
+            "iOS Bundle ID": game.details?.iosBundleId || "N/A",
+            "Android Package Name": game.details?.androidPackageName || "N/A",
+            "Semantic Version": game.details?.semanticVersion || "0.0.1",
+            "Build Number": game.details?.buildNumber || 1,
+            "GCP Project ID": game.details?.gcpProjectId || "N/A",
+            "GCP Service Account ID": game.details?.gcpServiceAccountId || "N/A"
+          }
+        }
+      ) })
+    );
+    return;
+  }
+}
+
+export { GameDetails as default };

package/dist/commands/game/export.js

@@ -0,0 +1,58 @@
+import { Args, Flags } from '@oclif/core';
+import { B as BaseAuthenticatedCommand, j as isCWDGodotGame, I as getProject, w as DEFAULT_IGNORED_FILES_GLOBS, x as DEFAULT_SHIPPED_FILES_GLOBS } from '../../index-DkNQs11R.js';
+import 'crypto';
+import 'fs';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import 'luxon';
+import 'axios';
+import 'isomorphic-git';
+import 'react';
+import '@tanstack/react-query';
+import 'uuid';
+import 'fast-glob';
+import 'yazl';
+import 'socket.io-client';
+import 'path';
+import '@expo/apple-utils/build/index.js';
+import 'crypto-js';
+import 'ini';
+import 'deepmerge';
+
+class GameExport extends BaseAuthenticatedCommand {
+  static args = {
+    game_id: Args.string({ description: 'The ID of the game to export (use "list" to get the ID)', required: true })
+  };
+  static description = "Downloads the shipthis.json file for a given game into the current directory.";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> abcd1234",
+    "<%= config.bin %> <%= command.id %> abcd1234 --force"
+  ];
+  static flags = {
+    force: Flags.boolean({ char: "f" })
+  };
+  async run() {
+    const { args } = this;
+    if (!isCWDGodotGame()) {
+      return this.error("No Godot project detected. Please run this from a godot project directory.", { exit: 1 });
+    }
+    if (this.hasProjectConfig() && !this.flags.force) {
+      return this.error(
+        "This project has already been initialized. Use --force to overwrite the existing configuration.",
+        { exit: 1 }
+      );
+    }
+    const project = await getProject(args.game_id);
+    await this.setProjectConfig({
+      project,
+      shippedFilesGlobs: DEFAULT_SHIPPED_FILES_GLOBS,
+      ignoredFilesGlobs: DEFAULT_IGNORED_FILES_GLOBS
+    });
+    await this.config.runCommand("game:status");
+    this.exit(0);
+  }
+}
+
+export { GameExport as default };

package/dist/commands/game/ios/app/addTester.js

@@ -0,0 +1,124 @@
+import { jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Flags } from '@oclif/core';
+import 'react';
+import '../../../../index-nnzhQ3nY.js';
+import { c as BaseGameCommand, i as BetaGroup } from '../../../../index-DkNQs11R.js';
+import 'ink-spinner';
+import 'axios';
+import 'crypto-js';
+import 'uuid';
+import 'fs';
+import 'luxon';
+import '@inkjs/ui';
+import '@tanstack/react-query';
+import 'yazl';
+import { a as getInput } from '../../../../index-BB00V5oF.js';
+import 'open';
+import 'marked';
+import 'marked-terminal';
+import 'path';
+import 'qrcode';
+import { R as RunWithSpinner } from '../../../../RunWithSpinner-BVXNWGD3.js';
+import 'string-length';
+import 'strip-ansi';
+import { q as queryAppleApp } from '../../../../useAppleApp-B16WbUxJ.js';
+import 'fast-glob';
+import { C as Command } from '../../../../Command-B3AmRt2w.js';
+import 'socket.io-client';
+import '../../../../useAndroidServiceAccountTestResult-DcYDam-p.js';
+import '@expo/apple-utils/build/index.js';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import 'isomorphic-git';
+import 'ini';
+import 'deepmerge';
+
+const TEST_GROUP_NAME = "ShipThis Test Group";
+class GameIosAppAddTester extends BaseGameCommand {
+  static args = {};
+  static description = "Adds a test user to the game in App Store Connect.";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    gameId: Flags.string({ char: "g", description: "The ID of the game" }),
+    email: Flags.string({ char: "e", description: "The email address of the tester" }),
+    firstName: Flags.string({ char: "f", description: "The first name of the tester" }),
+    lastName: Flags.string({ char: "l", description: "The last name of the tester" })
+  };
+  async run() {
+    const game = await this.getGame();
+    const authState = await this.refreshAppleAuthState();
+    const ctx = authState.context;
+    const { flags } = this;
+    const getEmail = async () => {
+      if (flags.email) return flags.email;
+      const question = `Please enter the email address of the tester: `;
+      const enteredEmail = await getInput(question);
+      if (!enteredEmail) {
+        this.error("No email address provided");
+      }
+      return enteredEmail;
+    };
+    const getFirstName = async () => {
+      if (flags.firstName) return flags.firstName;
+      const suggestedName = "John";
+      const question = `Please enter the first name of the tester, or press enter to use ${suggestedName}: `;
+      const enteredName = await getInput(question);
+      return enteredName || suggestedName;
+    };
+    const getLastName = async () => {
+      if (flags.lastName) return flags.lastName;
+      const suggestedName = "Doe";
+      const question = `Please enter the last name of the tester, or press enter to use ${suggestedName}: `;
+      const enteredName = await getInput(question);
+      return enteredName || suggestedName;
+    };
+    const email = await getEmail();
+    const firstName = await getFirstName();
+    const lastName = await getLastName();
+    console.warn("This command does not yet work. It fails with an assertion error.");
+    const addTestUser = async () => {
+      const { app } = await queryAppleApp({ ctx, iosBundleId: game.details?.iosBundleId });
+      if (!app) return this.error("No app found");
+      const groups = await BetaGroup.getAsync(ctx, {});
+      let shipThisGroup = groups.find(
+        (group) => group.attributes.name === TEST_GROUP_NAME && group.attributes.isInternalGroup
+      );
+      if (!shipThisGroup) {
+        shipThisGroup = await BetaGroup.createAsync(ctx, {
+          id: app.id,
+          name: TEST_GROUP_NAME,
+          isInternalGroup: true,
+          publicLinkEnabled: false,
+          publicLinkLimit: 1,
+          publicLinkLimitEnabled: false
+        });
+      }
+      await shipThisGroup.createBulkBetaTesterAssignmentsAsync([
+        {
+          email,
+          firstName,
+          lastName
+        }
+      ]);
+    };
+    const handleComplete = async () => {
+    };
+    render(
+      /* @__PURE__ */ jsx(Command, { command: this, children: /* @__PURE__ */ jsx(
+        RunWithSpinner,
+        {
+          msgInProgress: "Adding test user...",
+          msgComplete: "Added test user",
+          executeMethod: addTestUser,
+          onComplete: handleComplete
+        }
+      ) })
+    );
+  }
+}
+
+export { GameIosAppAddTester as default };

package/dist/commands/game/ios/app/create.js

@@ -0,0 +1,117 @@
+import { jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Flags } from '@oclif/core';
+import 'react';
+import '../../../../index-nnzhQ3nY.js';
+import { c as BaseGameCommand, d as getGodotAppleBundleIdentifier, e as BundleId, f as App } from '../../../../index-DkNQs11R.js';
+import 'ink-spinner';
+import 'axios';
+import 'crypto-js';
+import 'uuid';
+import 'fs';
+import 'luxon';
+import '@inkjs/ui';
+import '@tanstack/react-query';
+import 'yazl';
+import { a as getInput, b as generatePackageName } from '../../../../index-BB00V5oF.js';
+import 'open';
+import 'marked';
+import 'marked-terminal';
+import 'path';
+import 'qrcode';
+import { R as RunWithSpinner } from '../../../../RunWithSpinner-BVXNWGD3.js';
+import 'string-length';
+import 'strip-ansi';
+import 'fast-glob';
+import { C as Command } from '../../../../Command-B3AmRt2w.js';
+import 'socket.io-client';
+import '../../../../useAndroidServiceAccountTestResult-DcYDam-p.js';
+import '@expo/apple-utils/build/index.js';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import 'isomorphic-git';
+import 'ini';
+import 'deepmerge';
+
+class GameIosAppCreate extends BaseGameCommand {
+  static args = {};
+  static description = "Creates an App and BundleId in the Apple Developer Portal.";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    quiet: Flags.boolean({ char: "q", description: "Avoid output except for interactions and errors" }),
+    gameId: Flags.string({ char: "g", description: "The ID of the game" }),
+    appName: Flags.string({ char: "n", description: "The name of the App in the Apple Developer Portal" }),
+    bundleId: Flags.string({ char: "b", description: "The BundleId in the Apple Developer Portal" }),
+    force: Flags.boolean({ char: "f" })
+    // not used but don't remove or the wizard breaks
+  };
+  async run() {
+    const game = await this.getGame();
+    const authState = await this.refreshAppleAuthState();
+    const ctx = authState.context;
+    const { flags } = this;
+    const { appName, bundleId } = flags;
+    const getAppName = async () => {
+      if (appName) return appName;
+      const suggestedName = game.name;
+      const question = `Please enter the name of the App in the Apple Developer Portal, or press enter to use ${suggestedName}: `;
+      const enteredName = await getInput(question);
+      return enteredName || suggestedName;
+    };
+    const getBundleIdentifier = async () => {
+      if (bundleId) return bundleId;
+      const generatedBundleId = generatePackageName(game.name);
+      const suggestedBundleId = game.details?.iosBundleId || getGodotAppleBundleIdentifier() || generatedBundleId || "com.example.game";
+      const question = `Please enter the BundleId in the Apple Developer Portal, or press enter to use ${suggestedBundleId}: `;
+      const enteredBundleId = await getInput(question);
+      return enteredBundleId || suggestedBundleId;
+    };
+    const name = await getAppName();
+    const iosBundleId = await getBundleIdentifier();
+    const createApp = async () => {
+      this.log(`Checking for ${iosBundleId} in apple portal...`);
+      let bundleId2 = await BundleId.findAsync(ctx, { identifier: iosBundleId });
+      if (!bundleId2) {
+        this.log(`Creating BundleId ${iosBundleId} in apple portal...`);
+        bundleId2 = await BundleId.createAsync(ctx, {
+          identifier: iosBundleId,
+          name
+        });
+      }
+      let app = await App.findAsync(ctx, {
+        bundleId: iosBundleId
+      });
+      if (!app) {
+        this.log(`Creating App ${iosBundleId} in apple portal...`);
+        app = await App.createAsync(ctx, {
+          bundleId: iosBundleId,
+          name,
+          primaryLocale: "en-US"
+          // TODO
+        });
+      }
+      await this.updateGame({ details: { ...game.details, iosBundleId } });
+    };
+    const handleComplete = async () => {
+      await this.config.runCommand("game:ios:app:sync", ["--gameId", game.id]);
+      process.exit(0);
+    };
+    if (this.flags.quiet) return await createApp();
+    render(
+      /* @__PURE__ */ jsx(Command, { command: this, children: /* @__PURE__ */ jsx(
+        RunWithSpinner,
+        {
+          msgInProgress: "Creating App and BundleId in the Apple Developer Portal",
+          msgComplete: "App and BundleId created",
+          executeMethod: createApp,
+          onComplete: handleComplete
+        }
+      ) })
+    );
+  }
+}
+
+export { GameIosAppCreate as default };

package/dist/commands/game/ios/app/status.js

@@ -0,0 +1,66 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Flags } from '@oclif/core';
+import 'react';
+import '../../../../index-nnzhQ3nY.js';
+import { c as BaseGameCommand } from '../../../../index-DkNQs11R.js';
+import 'ink-spinner';
+import 'axios';
+import 'crypto-js';
+import 'uuid';
+import 'fs';
+import 'luxon';
+import '@inkjs/ui';
+import '@tanstack/react-query';
+import 'yazl';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import 'isomorphic-git';
+import 'fast-glob';
+import 'socket.io-client';
+import 'open';
+import 'marked';
+import 'marked-terminal';
+import 'path';
+import { N as NextSteps } from '../../../../NextSteps-CK9zHOCt.js';
+import 'qrcode';
+import 'string-length';
+import 'strip-ansi';
+import { A as AppleAppDetails, a as AppleBundleIdDetails } from '../../../../AppleBundleIdDetails-mPUG2R4N.js';
+import { C as Command } from '../../../../Command-B3AmRt2w.js';
+import '../../../../index-BB00V5oF.js';
+import '../../../../useAndroidServiceAccountTestResult-DcYDam-p.js';
+import '@expo/apple-utils/build/index.js';
+import 'ini';
+import 'deepmerge';
+import '../../../../Title-BCQtayg6.js';
+import '../../../../useAppleApp-B16WbUxJ.js';
+import '../../../../Table-CvM6pccN.js';
+import '../../../../useAppleBundleId-DobPATan.js';
+
+class GameIosAppStatus extends BaseGameCommand {
+  static args = {};
+  static description = "Shows the Game iOS App status. ";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    gameId: Flags.string({ char: "g", description: "The ID of the game" })
+  };
+  async run() {
+    const game = await this.getGame();
+    const authState = await this.refreshAppleAuthState();
+    const ctx = authState.context;
+    const steps = [];
+    render(
+      /* @__PURE__ */ jsxs(Command, { command: this, children: [
+        /* @__PURE__ */ jsx(AppleAppDetails, { iosBundleId: game.details?.iosBundleId, ctx }),
+        /* @__PURE__ */ jsx(AppleBundleIdDetails, { iosBundleId: game.details?.iosBundleId, ctx }),
+        /* @__PURE__ */ jsx(NextSteps, { steps })
+      ] })
+    );
+  }
+}
+
+export { GameIosAppStatus as default };

package/dist/commands/game/ios/app/sync.js

@@ -0,0 +1,95 @@
+import { jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Flags } from '@oclif/core';
+import 'react';
+import '../../../../index-nnzhQ3nY.js';
+import { c as BaseGameCommand, h as CapabilityTypeOption } from '../../../../index-DkNQs11R.js';
+import 'ink-spinner';
+import 'axios';
+import 'crypto-js';
+import 'uuid';
+import 'fs';
+import 'luxon';
+import '@inkjs/ui';
+import '@tanstack/react-query';
+import 'yazl';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import 'isomorphic-git';
+import { f as fetchBundleId } from '../../../../useAppleBundleId-DobPATan.js';
+import 'fast-glob';
+import 'socket.io-client';
+import 'open';
+import 'marked';
+import 'marked-terminal';
+import 'path';
+import 'qrcode';
+import { R as RunWithSpinner } from '../../../../RunWithSpinner-BVXNWGD3.js';
+import 'string-length';
+import 'strip-ansi';
+import { C as Command } from '../../../../Command-B3AmRt2w.js';
+import '../../../../index-BB00V5oF.js';
+import '../../../../useAndroidServiceAccountTestResult-DcYDam-p.js';
+import '@expo/apple-utils/build/index.js';
+import 'ini';
+import 'deepmerge';
+
+class GameIosAppSync extends BaseGameCommand {
+  static args = {};
+  static description = 'Synchronies the Apple App "BundleId" with the capabilities from the local project.';
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    quiet: Flags.boolean({ char: "q", description: "Avoid output except for interactions and errors" }),
+    gameId: Flags.string({ char: "g", description: "The ID of the game" }),
+    force: Flags.boolean({ char: "f" })
+    // not used but don't remove or the wizard breaks
+  };
+  async run() {
+    const game = await this.getGame();
+    const authState = await this.refreshAppleAuthState();
+    const ctx = authState.context;
+    if (!game.details?.iosBundleId) return this.error("Please run `shipthis game ios app create` first");
+    const { iosBundleId } = game.details;
+    const syncCapabilities = async () => {
+      const bundleQueryResponse = await fetchBundleId({ ctx, iosBundleId });
+      const { bundleId, capabilities: existing, projectCapabilities } = bundleQueryResponse;
+      if (!bundleId) return this.error("BundleId not found");
+      if (!projectCapabilities) return this.error("Project capabilities not loaded");
+      const unRemovable = ["IN_APP_PURCHASE"];
+      const toRemove = existing.filter((c) => !projectCapabilities.includes(c) && !unRemovable.includes(c));
+      const toAdd = projectCapabilities.filter((c) => !existing.includes(c));
+      for (const capability of toRemove) {
+        await bundleId.updateBundleIdCapabilityAsync({
+          capabilityType: capability,
+          option: CapabilityTypeOption.OFF
+        });
+      }
+      for (const capability of toAdd) {
+        await bundleId.updateBundleIdCapabilityAsync({
+          capabilityType: capability,
+          option: CapabilityTypeOption.ON
+        });
+      }
+    };
+    const handleComplete = async () => {
+      await this.config.runCommand("game:ios:app:status", ["--gameId", game.id]);
+    };
+    if (this.flags.quiet) return await syncCapabilities();
+    render(
+      /* @__PURE__ */ jsx(Command, { command: this, children: /* @__PURE__ */ jsx(
+        RunWithSpinner,
+        {
+          msgInProgress: "Syncing App Store BundleId capabilities",
+          msgComplete: "App Store BundleId capabilities synced",
+          executeMethod: syncCapabilities,
+          onComplete: handleComplete
+        }
+      ) })
+    );
+  }
+}
+
+export { GameIosAppSync as default };