hotcodepush 0.1.0 → 0.2.0

package/dist/utils/channel-fields.js

@@ -28,11 +28,11 @@ export const failurePolicyShape = {
 export const channelFieldsShape = {
     discoverable: booleanFlagSchema
         .optional()
-        .describe("Whether the app's setChannel finds the channel by its name; pass false to turn it off."),
+        .describe("Whether the app's setChannel finds the channel by its name. Pass false to turn it off."),
     expiresAt: z
         .string()
         .optional()
-        .describe('When the preview channel expires, an ISO 8601 timestamp; not on protected or default channels.'),
+        .describe('When the preview channel expires, an ISO 8601 timestamp. Protected and default channels have none.'),
     expiresIn: z
         .string()
         .regex(DURATION_PATTERN, 'Expected a number of days or hours such as 14d or 12h')
@@ -41,7 +41,7 @@ export const channelFieldsShape = {
     ...failurePolicyShape,
     protected: booleanFlagSchema
         .optional()
-        .describe('Whether only Owners and Admins change what the channel serves; pass false to turn it off.'),
+        .describe('Whether only Owners and Admins change what the channel serves. Pass false to turn it off.'),
 };
 export const channelFieldsClearShape = {
     clearExpiresAt: z

package/dist/utils/cli.js

@@ -1,5 +1,6 @@
 import { stripVTControlCharacters } from 'node:util';
 import { defineConfig, processConfig } from 'zodline';
+import { ensureAuthentication } from './authentication.js';
 import { loadCommands, resolveInvocation } from './command-registry.js';
 import { isColorEnabled } from './environment.js';
 import { printError, resolveCliError } from './error-mapping.js';
@@ -55,6 +56,10 @@ async function runCommandLine(commandRegistry, argv, meta) {
         const { args, command, options } = isColorEnabled(process.stdout)
             ? processConfig(config, invocation.argv)
             : processConfigWithoutColor(config, invocation.argv);
+        if (commandName !== undefined &&
+            commands[commandName]?.authentication === 'required') {
+            await ensureAuthentication(options);
+        }
         await command.action(options, args);
         return { cliError: undefined, commandName };
     }

package/dist/utils/command.js

@@ -0,0 +1,4 @@
+import { defineCommand as defineZodlineCommand } from 'zodline';
+export function defineCommand({ authentication = 'required', ...command }) {
+    return { ...defineZodlineCommand(command), authentication };
+}

package/dist/utils/diagnostics.js

@@ -0,0 +1,20 @@
+import { styleText } from 'node:util';
+import { log } from '@clack/prompts';
+import { isColorEnabled } from './environment.js';
+// A diagnostic addresses the person, so it goes to stderr in the gutter the prompts use; stdout stays the command's result.
+const STDERR = { output: process.stderr };
+export function printError({ docsUrl, sentences }) {
+    const styledDocsUrl = isColorEnabled(process.stderr)
+        ? styleText('dim', docsUrl, { validateStream: false })
+        : docsUrl;
+    log.error([...sentences, styledDocsUrl].join('\n'), STDERR);
+}
+export function printNotice(text) {
+    log.info(text, STDERR);
+}
+export function printSuccess(text) {
+    log.success(text, STDERR);
+}
+export function printWarning(text) {
+    log.warn(text, STDERR);
+}

package/dist/utils/error-mapping.js

@@ -1,9 +1,9 @@
-import { inspect, stripVTControlCharacters, styleText } from 'node:util';
+import { inspect, stripVTControlCharacters } from 'node:util';
 import { HotCodePushError } from '@hotcodepush/node';
 import { ZodError } from 'zod';
 import { ZodlineError } from 'zodline';
 import { ERRORS_DOCS_URL } from '../config/consts.js';
-import { isColorEnabled } from './environment.js';
+import { printError as printErrorDiagnostic } from './diagnostics.js';
 import { ApiError, CliError, InvalidParameterError, UnexpectedError, UnexpectedResponseError, } from './errors.js';
 import { resolveFlagName } from './flag-name.js';
 import { printJson } from './output.js';
@@ -16,16 +16,12 @@ export function buildErrorJson({ code, fix, message }) {
 export function resolveSentence(message) {
     return SENTENCE_END_PATTERN.test(message) ? message : `${message}.`;
 }
+export function resolveErrorDocsUrl({ code }) {
+    return `${ERRORS_DOCS_URL}#${code}`;
+}
 // An API error message says what to do itself, so it has no fix.
-export function buildErrorLines({ code, fix, message }, options) {
-    const sentence = fix === null ? message : resolveSentence(message);
-    const styledSentence = options.isColorEnabled
-        ? styleText('red', sentence, { validateStream: false })
-        : sentence;
-    return [
-        fix === null ? styledSentence : `${styledSentence} ${fix}`,
-        `${ERRORS_DOCS_URL}#${code}`,
-    ];
+export function resolveErrorSentences({ fix, message }) {
+    return fix === null ? [message] : [resolveSentence(message), fix];
 }
 export function printError(cliError, { isJson, isVerbose }) {
     if (isVerbose) {
@@ -35,10 +31,10 @@ export function printError(cliError, { isJson, isVerbose }) {
         printJson(buildErrorJson(cliError));
     }
     else {
-        const errorLines = buildErrorLines(cliError, {
-            isColorEnabled: isColorEnabled(process.stderr),
+        printErrorDiagnostic({
+            docsUrl: resolveErrorDocsUrl(cliError),
+            sentences: resolveErrorSentences(cliError),
         });
-        process.stderr.write(`${errorLines.join('\n')}\n`);
     }
 }
 // A response without a code, such as a proxy HTML page, is not an error from the API catalog.

package/dist/utils/login.js

@@ -0,0 +1,153 @@
+import { setTimeout } from 'node:timers/promises';
+import { CLI_CLIENT_ID } from '../config/consts.js';
+import { createApiAuthClient, fetchSession, resolveResponseData, } from './auth-client.js';
+import { openBrowser } from './browser.js';
+import { printNotice } from './diagnostics.js';
+import { isInteractive } from './environment.js';
+import { resolveApiError } from './error-mapping.js';
+import { LoginDeniedError, LoginExpiredError, NotLoggedInError, } from './errors.js';
+import { writeToken } from './token-store.js';
+import { readUserConfig, writeStoredSession, writeUserConfig, } from './user-config.js';
+// RFC 8628, section 3.2: without an interval from the server, a client polls every five seconds.
+const DEFAULT_INTERVAL_SECONDS = 5;
+const DEVICE_CODE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:device_code';
+// RFC 8628, section 3.5: each slow_down adds five seconds to this and every later interval.
+const SLOW_DOWN_INCREMENT_SECONDS = 5;
+// The page and the code go to stderr, so the stdout of the calling command stays its own.
+export async function logIn(options) {
+    const authClient = createApiAuthClient();
+    const sessionToken = await fetchSessionToken(authClient, isInteractive(options));
+    const { session, user } = await fetchSession(createApiAuthClient(sessionToken));
+    writeToken(sessionToken);
+    deletePendingDeviceAuthorization();
+    writeStoredSession(session);
+    return { email: user.email, id: user.id, name: user.name };
+}
+// A request without an answer or with a transient status is polled again, since the person may be approving meanwhile.
+async function fetchApprovedSessionToken(authClient, deviceAuthorization) {
+    let currentIntervalSeconds = deviceAuthorization.intervalSeconds;
+    for (;;) {
+        await setTimeout(currentIntervalSeconds * 1000);
+        if (isDeviceAuthorizationExpired(deviceAuthorization)) {
+            throw new LoginExpiredError();
+        }
+        const response = await fetchDeviceToken(authClient, deviceAuthorization.deviceCode).catch(() => undefined);
+        if (response === undefined) {
+            continue;
+        }
+        const { data, error } = response;
+        if (error === null) {
+            return data.access_token;
+        }
+        switch (error.error) {
+            case 'access_denied':
+                throw new LoginDeniedError();
+            case 'authorization_pending':
+                break;
+            case 'expired_token':
+                throw new LoginExpiredError();
+            case 'slow_down':
+                currentIntervalSeconds += SLOW_DOWN_INCREMENT_SECONDS;
+                break;
+            default:
+                if (!isTransientStatus(error.status)) {
+                    throw resolveApiError(error);
+                }
+        }
+    }
+}
+async function fetchDeviceAuthorization(authClient) {
+    const { device_code, expires_in, interval, user_code, verification_uri_complete, } = resolveResponseData(await authClient.device.code({ client_id: CLI_CLIENT_ID }));
+    return {
+        deviceCode: device_code,
+        expiresAt: new Date(Date.now() + expires_in * 1000).toISOString(),
+        intervalSeconds: interval,
+        userCode: user_code,
+        verificationUrl: verification_uri_complete,
+    };
+}
+function fetchDeviceToken(authClient, deviceCode) {
+    return authClient.device.token({
+        client_id: CLI_CLIENT_ID,
+        device_code: deviceCode,
+        grant_type: DEVICE_CODE_GRANT_TYPE,
+    });
+}
+// A code that a non-interactive login kept is redeemed first, with one token request.
+// While pending it is shown again. Denied, expired or unknown, it gives way to a new one.
+async function fetchSessionToken(authClient, isLoginInteractive) {
+    const pendingDeviceAuthorization = readPendingDeviceAuthorization();
+    if (pendingDeviceAuthorization !== undefined &&
+        !isDeviceAuthorizationExpired(pendingDeviceAuthorization)) {
+        const { data, error } = await fetchDeviceToken(authClient, pendingDeviceAuthorization.deviceCode);
+        if (error === null) {
+            return data.access_token;
+        }
+        switch (error.error) {
+            case 'access_denied':
+            case 'expired_token':
+            case 'invalid_grant':
+                break;
+            case 'authorization_pending':
+            case 'slow_down':
+                return fetchSessionTokenOnApproval(authClient, pendingDeviceAuthorization, isLoginInteractive);
+            default:
+                throw resolveApiError(error);
+        }
+    }
+    deletePendingDeviceAuthorization();
+    return fetchSessionTokenOnApproval(authClient, await fetchDeviceAuthorization(authClient), isLoginInteractive);
+}
+// The code is kept, so the next login redeems one that ended before the approval.
+async function fetchSessionTokenOnApproval(authClient, deviceAuthorization, isLoginInteractive) {
+    writePendingDeviceAuthorization(deviceAuthorization);
+    if (!isLoginInteractive) {
+        throw new NotLoggedInError(deviceAuthorization);
+    }
+    printNotice(`Open ${deviceAuthorization.verificationUrl} and approve the code ${deviceAuthorization.userCode}.\nWaiting for the approval…`);
+    await openBrowser(deviceAuthorization.verificationUrl);
+    return fetchApprovedSessionToken(authClient, deviceAuthorization);
+}
+function deletePendingDeviceAuthorization() {
+    const userConfig = readUserConfig();
+    if (userConfig.pendingDeviceCode === undefined) {
+        return;
+    }
+    delete userConfig.pendingDeviceCode;
+    delete userConfig.pendingDeviceCodeExpiresAt;
+    delete userConfig.pendingUserCode;
+    delete userConfig.pendingVerificationUrl;
+    writeUserConfig(userConfig);
+}
+function isDeviceAuthorizationExpired({ expiresAt, }) {
+    return new Date(expiresAt) <= new Date();
+}
+// The statuses the Node client also retries: a timeout, the rate limit or a server error.
+function isTransientStatus(status) {
+    return status === 408 || status === 429 || status >= 500;
+}
+function readPendingDeviceAuthorization() {
+    const { pendingDeviceCode, pendingDeviceCodeExpiresAt, pendingUserCode, pendingVerificationUrl, } = readUserConfig();
+    if (pendingDeviceCode === undefined ||
+        pendingDeviceCodeExpiresAt === undefined ||
+        pendingUserCode === undefined ||
+        pendingVerificationUrl === undefined) {
+        return undefined;
+    }
+    return {
+        deviceCode: pendingDeviceCode,
+        expiresAt: pendingDeviceCodeExpiresAt,
+        intervalSeconds: DEFAULT_INTERVAL_SECONDS,
+        userCode: pendingUserCode,
+        verificationUrl: pendingVerificationUrl,
+    };
+}
+function writePendingDeviceAuthorization({ deviceCode, expiresAt, userCode, verificationUrl, }) {
+    writeUserConfig({
+        ...readUserConfig(),
+        pendingDeviceCode: deviceCode,
+        pendingDeviceCodeExpiresAt: expiresAt,
+        pendingUserCode: userCode,
+        pendingVerificationUrl: verificationUrl,
+    });
+}

package/dist/utils/output.js

@@ -1,3 +1,4 @@
+import { printWarning } from './diagnostics.js';
 export function printDetails(details) {
     const labelWidth = Math.max(...details.map(([label]) => label.length));
     for (const [label, value] of details) {
@@ -10,7 +11,7 @@ export function printJson(data) {
 // The API warns when a computed preview is likely not what was meant.
 export function printWarnings(warnings) {
     for (const { message } of warnings) {
-        process.stderr.write(`Warning: ${message}\n`);
+        printWarning(message);
     }
 }
 export function printTable({ emptyText, headers, nextOffset, rows, }) {

package/dist/utils/release-conditions.js

@@ -1,4 +1,4 @@
-import { hashAttribute, hashDeviceId, isValidAttributeKey, isValidAttributeValue, } from '@hotcodepush/protocol';
+import { isValidAttributeKey, isValidAttributeValue, } from '@hotcodepush/protocol';
 import { z } from 'zod';
 import { InvalidParameterError } from './errors.js';
 export const conditionOptionShape = {
@@ -30,14 +30,13 @@ export function buildAudienceQuery(options, fingerprint, rolloutPercent) {
         rolloutPercent,
     };
 }
-// Matches the index: attribute values and device ids are hashed, and all device ids share one condition.
 export function buildReleaseConditions(options, fingerprint) {
     const deviceIds = options.device ?? [];
     return [
         ...resolveAttributePairs(options.attribute).map(({ key, value }) => ({
             key,
             type: 'attribute',
-            valueSha256: hashAttribute(key, value),
+            value,
         })),
         ...resolveList(options.binaryVersion).map((range) => ({
             range,
@@ -47,7 +46,7 @@ export function buildReleaseConditions(options, fingerprint) {
             ? []
             : [
                 {
-                    hashedIds: deviceIds.map(hashDeviceId),
+                    ids: deviceIds,
                     type: 'device',
                 },
             ]),

package/dist/utils/release-output.js

@@ -8,6 +8,6 @@ export function resolveProgressingText({ progression }) {
 }
 function resolveLiveText(release) {
     return release.liveAt === null
-        ? '; not live yet, and "release get" shows when it is'
+        ? '. Not live yet, and "release get" shows when it is'
         : `, live since ${release.liveAt}`;
 }

package/dist/utils/resource-resolution.js

@@ -9,7 +9,7 @@ export const channelOptionShape = {
     channel: z
         .string()
         .optional()
-        .describe("The channel, by id or name; hotcodepush.json's channel by default."),
+        .describe("The channel, by id or name. Defaults to hotcodepush.json's channel."),
 };
 // A name is looked up in `--organization` when given, otherwise in every organization of the user.
 export async function fetchAppId(hotCodePush, options, projectConfig) {

package/dist/utils/telemetry.js

@@ -3,13 +3,14 @@ import { hostname } from 'node:os';
 import { basename } from 'node:path/posix';
 import { setTimeout } from 'node:timers/promises';
 import { PACKAGE_JSON, POSTHOG_HOST, POSTHOG_PROJECT_KEY, SENTRY_DSN, } from '../config/consts.js';
+import { printNotice } from './diagnostics.js';
 import { isCi } from './environment.js';
 import { ReportedFailureError, UnexpectedError, UnexpectedResponseError, } from './errors.js';
 import { ignoreUserConfigErrors, readUserConfig, writeUserConfig, } from './user-config.js';
 const COMMAND_FINISHED_EVENT = 'cli.command_finished';
 // Matches `at <function> (<file>:<line>:<column>)`, or the same without the function and parentheses.
 const STACK_FRAME_PATTERN = /^\s*at (?:(.+?) \()?(.+?):(\d+):(\d+)\)?$/;
-const TELEMETRY_NOTICE = 'HotCodePush collects anonymous usage and error data to improve the CLI; set HOTCODEPUSH_TELEMETRY_DISABLED=1 to opt out.';
+const TELEMETRY_NOTICE = 'HotCodePush collects anonymous usage and error data to improve the CLI. Set HOTCODEPUSH_TELEMETRY_DISABLED=1 to opt out.';
 // The longest telemetry may delay the exit, requests included.
 const TELEMETRY_TIMEOUT_MS = 1500;
 // Only the release build has keys, so every other build reports nothing.
@@ -27,7 +28,7 @@ export function printTelemetryNotice() {
         if (userConfig.telemetryNoticeShownAt !== undefined) {
             return;
         }
-        process.stderr.write(`${TELEMETRY_NOTICE}\n`);
+        printNotice(TELEMETRY_NOTICE);
         writeUserConfig({
             ...userConfig,
             telemetryNoticeShownAt: new Date().toISOString(),

package/dist/utils/update-notice.js

@@ -1,4 +1,5 @@
 import { PACKAGE_JSON } from '../config/consts.js';
+import { printNotice } from './diagnostics.js';
 import { isCi } from './environment.js';
 import { ignoreUserConfigErrors, readUserConfig, writeUserConfig, } from './user-config.js';
 const LATEST_VERSION_URL = `https://registry.npmjs.org/${PACKAGE_JSON.name}/latest`;
@@ -22,7 +23,7 @@ export function printUpdateNotice() {
         const { latestKnownVersion } = readUserConfig();
         if (latestKnownVersion !== undefined &&
             isNewerVersion(latestKnownVersion, PACKAGE_JSON.version)) {
-            process.stderr.write(`HotCodePush CLI ${latestKnownVersion} is available; you run ${PACKAGE_JSON.version}.\n`);
+            printNotice(`HotCodePush CLI ${latestKnownVersion} is available. You run ${PACKAGE_JSON.version}.`);
         }
     });
 }

package/dist/utils/usage-month.js

@@ -3,7 +3,7 @@ export const monthOptionShape = {
     month: z
         .string()
         .optional()
-        .describe('The month, YYYY-MM; the current one by default.'),
+        .describe('The month, YYYY-MM. Defaults to the current one.'),
 };
 export function resolveMonthText(month) {
     return new Date(`${month}-01T00:00:00.000Z`).toLocaleString('en-US', {

package/dist/utils/user-config.js

@@ -31,6 +31,14 @@ export function resolveConfigDirectoryPath() {
         : process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
     return join(baseDirectoryPath, CONFIG_DIRECTORY_NAME);
 }
+// The expiry is the local hint that a session may have ended; the API's answer is the fact.
+export function writeStoredSession({ expiresAt, id }) {
+    writeUserConfig({
+        ...readUserConfig(),
+        sessionExpiresAt: new Date(expiresAt).toISOString(),
+        sessionId: id,
+    });
+}
 export function writeUserConfig(userConfig) {
     const filePath = resolveConfigFilePath();
     mkdirSync(resolveConfigDirectoryPath(), { recursive: true });

package/dist/utils/webhook-resolution.js

@@ -7,7 +7,7 @@ export const webhookAppOptionShape = {
     app: z
         .string()
         .optional()
-        .describe("The app, by id or name, whose events alone the webhook receives; every app's and the organization's by default, never hotcodepush.json's app."),
+        .describe("The app, by id or name, whose events alone the webhook receives. Defaults to every app's and the organization's events, never to hotcodepush.json's app."),
 };
 export const webhookEventOptionShape = {
     event: z

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hotcodepush",
   "description": "The HotCodePush CLI: set up, release and manage over-the-air (OTA) updates from the terminal and CI",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "license": "MIT",
   "homepage": "https://hotcodepush.com",
@@ -46,8 +46,8 @@
   },
   "dependencies": {
     "@clack/prompts": "1.8.1",
-    "@hotcodepush/node": "https://pkg.pr.new/hotcodepush-team/hotcodepush-node/@hotcodepush/node@3146611",
-    "@hotcodepush/protocol": "https://pkg.pr.new/hotcodepush-team/protocol/@hotcodepush/protocol@54a237c",
+    "@hotcodepush/node": "https://pkg.pr.new/hotcodepush-team/hotcodepush-node/@hotcodepush/node@9e671df",
+    "@hotcodepush/protocol": "https://pkg.pr.new/hotcodepush-team/protocol/@hotcodepush/protocol@5b27c65",
     "@napi-rs/keyring": "2.1.0",
     "better-auth": "1.7.12",
     "fast-xml-parser": "5.11.2",