@todesktop/shared 7.191.0 → 7.192.0

package/src/desktopify.ts

@@ -3,12 +3,13 @@ import {
   Configuration,
   PackagerOptions,
   PublishOptions,
-  // app-builder-lib shouldn't be installed as a dependency for dependent
-  // packages since it's too large
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
 } from 'app-builder-lib';
 import { IApp2 } from './desktopify2';
+import {
+  BreakpointPauseLease,
+  BreakpointQueueEntry,
+  CurrentBreakpointState,
+} from './introspection/breakpoints';
 import { IApp } from './toDesktop';
 
 type appBuilderLib = PackagerOptions & PublishOptions;
@@ -130,6 +131,46 @@ export interface PlatformBuild {
 
 export type CIRunner = 'azure' | 'circle';
 
+export type IntrospectBreakpointStatus =
+  | 'error'
+  | 'finished'
+  | 'initializing'
+  | 'paused'
+  | 'ready'
+  | 'resuming';
+
+export type IntrospectShellStatus =
+  | 'connected'
+  | 'connecting'
+  | 'disconnected'
+  | 'error'
+  | 'initializing'
+  | 'ready';
+
+export interface IntrospectPlatformData {
+  breakpointQueue?: BreakpointQueueEntry[];
+  breakpointStatus: IntrospectBreakpointStatus;
+  connectedAt?: Date;
+  connectedUserId?: string;
+  createdAt: ISODate;
+  currentBreakpoint?: CurrentBreakpointState;
+  disconnectedAt?: Date;
+  enabled: boolean;
+  error?: string;
+  jtiExpiresAt?: Date;
+  pauseLease?: BreakpointPauseLease;
+  sessionJti?: string;
+  shellStatus: IntrospectShellStatus;
+  tunnelUrl?: string;
+  usedJti?: string;
+}
+
+export interface IntrospectData {
+  linux: IntrospectPlatformData;
+  mac: IntrospectPlatformData;
+  windows: IntrospectPlatformData;
+}
+
 export interface Build {
   appCustomDomain?: string;
   appName: string;
@@ -161,6 +202,7 @@ export interface Build {
   hash?: string;
   icon?: string;
   id: string;
+  introspect?: IntrospectData;
   isArtifactsPruned?: boolean;
   isBeingCancelled?: boolean;
   linux?: PlatformBuild;

package/src/index.cjs.ts

@@ -0,0 +1,19 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+// CJS-specific entry point
+// Path is relative to lib/cjs/ output directory
+const packageJson = require('../../package.json');
+
+export * from './base';
+export * from './desktopify';
+export * from './desktopify2';
+export * from './getSiteInfo';
+export * from './hsm';
+export * from './invitePermissionLabels';
+export * from './personalAccessTokens';
+export * from './plans';
+export * from './plugin';
+export * from './toDesktop';
+
+export * from './validations';
+
+export const schemaVersion = packageJson.version;

package/src/index.ts

@@ -1,10 +1,12 @@
-import packageJson from '../package.json' with { type: 'json' };
+// Path is relative to lib/esm/ output directory
+import packageJson from '../../package.json' with { type: 'json' };
 
 export * from './base.js';
 export * from './desktopify.js';
 export * from './desktopify2.js';
 export * from './getSiteInfo.js';
 export * from './hsm.js';
+export * from './introspection/breakpoints.js';
 export * from './invitePermissionLabels.js';
 export * from './personalAccessTokens.js';
 export * from './plans.js';

package/src/introspection/__tests__/breakpoints.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import {
+  cloneBreakpointQueue,
+  isSameBreakpoint,
+  markQueueSkipped,
+} from '../breakpoints';
+import type { BreakpointQueueEntry } from '../breakpoints';
+
+describe('isSameBreakpoint', () => {
+  it('matches identical phase breakpoints', () => {
+    expect(
+      isSameBreakpoint(
+        { id: 'beforeInstall', type: 'phase' },
+        { id: 'beforeInstall', type: 'phase' },
+      ),
+    ).toBe(true);
+  });
+
+  it('fails when breakpoint types differ', () => {
+    expect(
+      isSameBreakpoint(
+        { id: 'beforeInstall', type: 'phase' },
+        { id: 'todesktop:beforeInstall', position: 'before', type: 'hook' },
+      ),
+    ).toBe(false);
+  });
+
+  it('considers hook positions', () => {
+    expect(
+      isSameBreakpoint(
+        { id: 'todesktop:beforeBuild', position: 'before', type: 'hook' },
+        { id: 'todesktop:beforeBuild', position: 'after', type: 'hook' },
+      ),
+    ).toBe(false);
+  });
+
+  it('returns false when either side is undefined', () => {
+    expect(
+      isSameBreakpoint(undefined, { id: 'afterInstall', type: 'phase' }),
+    ).toBe(false);
+  });
+});
+
+describe('cloneBreakpointQueue', () => {
+  it('produces a deep copy of the queue', () => {
+    const original: ReadonlyArray<BreakpointQueueEntry> = [
+      { hitAt: undefined, id: 'beforeInstall', type: 'phase' },
+      {
+        id: 'todesktop:afterPack',
+        position: 'after',
+        skipped: true,
+        type: 'hook',
+      },
+    ];
+
+    const copy = cloneBreakpointQueue(original);
+
+    expect(copy).toEqual(original);
+    expect(copy).not.toBe(original);
+    expect(copy[0]).not.toBe(original[0]);
+  });
+});
+
+describe('markQueueSkipped', () => {
+  it('marks the starting entry as skipped and adds fallback timestamps', () => {
+    const queue: ReadonlyArray<BreakpointQueueEntry> = [
+      { id: 'beforeInstall', type: 'phase' },
+      { id: 'afterInstall', type: 'phase' },
+    ];
+    const fallbackHitAt = '2024-01-01T00:00:00.000Z';
+
+    const updated = markQueueSkipped(queue, 0, { fallbackHitAt });
+
+    expect(updated[0]).toMatchObject({
+      hitAt: fallbackHitAt,
+      skipped: true,
+    });
+    expect(updated[1]).toMatchObject({ skipped: true });
+    expect(queue[0].skipped).toBeUndefined();
+  });
+
+  it('returns a cloned queue when index is out of bounds', () => {
+    const queue: ReadonlyArray<BreakpointQueueEntry> = [
+      { id: 'beforeInstall', type: 'phase' },
+    ];
+
+    const updated = markQueueSkipped(queue, 2);
+
+    expect(updated).toEqual(queue);
+    expect(updated).not.toBe(queue);
+  });
+});

package/src/introspection/breakpoints.ts

@@ -0,0 +1,137 @@
+const MINUTE = 60 * 1000;
+export const BREAKPOINT_DEFAULT_LEASE_MS = 20 * MINUTE; // 20 minutes
+export const BREAKPOINT_RENEW_INCREMENT_MS = 10 * MINUTE; // 10 minutes
+export const BREAKPOINT_MAX_REMAINING_MS = 20 * MINUTE; // 20 minutes
+
+export type PhaseBreakpointId =
+  | 'afterInstall'
+  | 'afterPack'
+  | 'afterSourcePrep'
+  | 'afterUpload'
+  | 'beforeFinalize'
+  | 'beforeInstall'
+  | 'beforePack'
+  | 'beforeUpload';
+
+export type HookBreakpointName =
+  | 'todesktop:afterPack'
+  | 'todesktop:beforeBuild'
+  | 'todesktop:beforeInstall';
+
+export type HookBreakpointPosition = 'after' | 'before';
+
+interface PhaseBreakpointConfig {
+  id: PhaseBreakpointId;
+  type: 'phase';
+}
+
+interface HookBreakpointConfig {
+  id: HookBreakpointName;
+  position: HookBreakpointPosition;
+  type: 'hook';
+}
+
+export type BreakpointConfig = HookBreakpointConfig | PhaseBreakpointConfig;
+
+export type BreakpointQueueEntry = {
+  autoResumed?: boolean;
+  hitAt?: string;
+  skipped?: boolean;
+} & BreakpointConfig;
+
+export interface BreakpointRenewal {
+  renewedAt: string;
+  renewedByUserId: string;
+}
+
+export type CurrentBreakpointState = {
+  createdAt: string;
+  expiresAt: string;
+  renewals?: BreakpointRenewal[];
+  resumedAt?: string;
+  resumedByUserId?: string;
+  skipped?: boolean;
+  wasAutoResumed?: boolean;
+} & BreakpointConfig;
+
+export interface BreakpointPauseLease {
+  createdAt: string;
+  createdByUserId: string;
+  defaultDurationMs: number;
+}
+
+export function isSameBreakpoint(
+  a:
+    | BreakpointConfig
+    | BreakpointQueueEntry
+    | CurrentBreakpointState
+    | undefined,
+  b:
+    | BreakpointConfig
+    | BreakpointQueueEntry
+    | CurrentBreakpointState
+    | undefined,
+): boolean {
+  if (!a || !b) {
+    return false;
+  }
+
+  if (a.type !== b.type) {
+    return false;
+  }
+
+  if (a.id !== b.id) {
+    return false;
+  }
+
+  if (isHookBreakpointConfig(a) && isHookBreakpointConfig(b)) {
+    return a.position === b.position;
+  }
+
+  return true;
+}
+
+function isHookBreakpointConfig(
+  config: BreakpointConfig | BreakpointQueueEntry | CurrentBreakpointState,
+): config is HookBreakpointConfig {
+  return config.type === 'hook';
+}
+
+export function cloneBreakpointQueue(
+  queue?: null | ReadonlyArray<BreakpointQueueEntry>,
+): BreakpointQueueEntry[] {
+  return Array.isArray(queue) ? queue.map((entry) => ({ ...entry })) : [];
+}
+
+export function markQueueSkipped(
+  queue: ReadonlyArray<BreakpointQueueEntry>,
+  startIndex: number,
+  options: { fallbackHitAt?: string } = {},
+): BreakpointQueueEntry[] {
+  const updated = cloneBreakpointQueue(queue);
+  const { fallbackHitAt } = options;
+
+  if (startIndex < 0 || startIndex >= updated.length) {
+    return updated;
+  }
+
+  const current = updated[startIndex];
+  const hitAt = current.hitAt ?? fallbackHitAt;
+
+  updated[startIndex] = {
+    ...current,
+    skipped: true,
+    ...(hitAt ? { hitAt } : {}),
+  };
+
+  for (let i = startIndex + 1; i < updated.length; i += 1) {
+    if (!updated[i].hitAt) {
+      updated[i] = {
+        ...updated[i],
+        skipped: true,
+      };
+    }
+  }
+
+  return updated;
+}

package/tsconfig.esm.json

@@ -0,0 +1,15 @@
+{
+  "extends": "@todesktop/dev-config/tsconfig.base.json",
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "./lib/esm",
+    "rootDir": "./src",
+    "resolveJsonModule": true,
+    "strict": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "lib", "src/index.cjs.ts"]
+}

package/tsconfig.json

@@ -2,14 +2,13 @@
   "extends": "@todesktop/dev-config/tsconfig.base.json",
   "compilerOptions": {
     "target": "es2016",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
+    "module": "commonjs",
     "declaration": true,
-    "outDir": "./lib",
+    "outDir": "./lib/cjs",
     "rootDir": "./src",
     "resolveJsonModule": true,
     "strict": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "lib"]
+  "exclude": ["node_modules", "lib", "src/index.ts"]
 }