@yalehwang/cloudpit 2.0.0 → 3.0.0

package/electron/tests/cloudpit-brand-env-wiring.test.mjs

@@ -0,0 +1,324 @@
+/**
+ * Criterion file for `gap-cloudpit-brand-env-reader-wiring` (v3.0 update).
+ *
+ *   npx tsx --tsconfig server/tsconfig.json --test electron/tests/cloudpit-brand-env-wiring.test.mjs
+ *
+ * Electron cannot import `server/shared/brand.ts` (it runs plain JavaScript from
+ * source), so the production wiring reads through `electron/brandEnv.js`. This
+ * file holds the two things that keep that second implementation honest:
+ *
+ *   1. a cross-runtime PARITY table: one environment table drives both
+ *      `createBrandEnvReader` implementations and compares `{value, source,
+ *      key}` so the semantics cannot drift;
+ *   2. the WIRING arms: the Electron control-plane resolver, the local-server
+ *      discovery keys and `ServerInstaller` resolve `CLOUDPIT_*` and keep their
+ *      shipped defaults when no brand variable is set.
+ *
+ * v3.0 RETIREMENT: the legacy `CLOUDCLI_*` spelling is no longer read anywhere.
+ * Every arm below that used to assert the fallback now asserts the ignored
+ * spelling leaves the shipped default in force.
+ *
+ * The production wiring is driven through the same functions the modules use.
+ * `electron/main.js` imports Electron and cannot be loaded by node, so the
+ * control-plane arm drives `readBrandEnvValue` (the expression main.js binds)
+ * and a static arm pins that main.js binds it, and that no Electron module
+ * reads a legacy spelling directly.
+ */
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+import {
+  createBrandEnvReader as createElectronBrandEnvReader,
+  readBrandEnvValue,
+} from '../brandEnv.js';
+import {
+  getExistingServerCandidateUrls,
+  isInstalledServerRequested,
+} from '../localServer.js';
+import { DEFAULT_INSTALL_ROOT, ServerInstaller } from '../serverInstaller.js';
+import { createBrandEnvReader as createServerBrandEnvReader } from '../../server/shared/brand.js';
+
+const TESTS_DIR = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(TESTS_DIR, '..', '..');
+
+function readRepoFile(relativePath) {
+  return readFileSync(path.join(REPO_ROOT, relativePath), 'utf8');
+}
+
+/** Build a reader over `env`. */
+function readWith(createReader, env) {
+  return createReader({ env });
+}
+
+// ── parity: the two createBrandEnvReader implementations ───────────────────
+
+/**
+ * The shared table. `expectedReadings` is what both implementations must return
+ * when the same key is read twice.
+ */
+const PARITY_ARMS = [
+  {
+    label: 'new only',
+    env: { CLOUDPIT_X: 'new' },
+    expectedReadings: [
+      { value: 'new', source: 'new', key: 'CLOUDPIT_X' },
+      { value: 'new', source: 'new', key: 'CLOUDPIT_X' },
+    ],
+  },
+  {
+    label: 'both set',
+    env: { CLOUDPIT_X: 'new', CLOUDCLI_X: 'old' },
+    expectedReadings: [
+      { value: 'new', source: 'new', key: 'CLOUDPIT_X' },
+      { value: 'new', source: 'new', key: 'CLOUDPIT_X' },
+    ],
+  },
+  {
+    label: 'legacy only',
+    env: { CLOUDCLI_X: 'old' },
+    expectedReadings: [
+      { value: undefined, source: 'absent', key: 'CLOUDPIT_X' },
+      { value: undefined, source: 'absent', key: 'CLOUDPIT_X' },
+    ],
+  },
+  {
+    label: 'both empty',
+    env: { CLOUDPIT_X: '', CLOUDCLI_X: '' },
+    expectedReadings: [
+      { value: undefined, source: 'absent', key: 'CLOUDPIT_X' },
+      { value: undefined, source: 'absent', key: 'CLOUDPIT_X' },
+    ],
+  },
+  {
+    label: 'new empty with legacy set',
+    env: { CLOUDPIT_X: '', CLOUDCLI_X: 'old' },
+    expectedReadings: [
+      { value: undefined, source: 'absent', key: 'CLOUDPIT_X' },
+      { value: undefined, source: 'absent', key: 'CLOUDPIT_X' },
+    ],
+  },
+  {
+    label: 'neither set',
+    env: {},
+    expectedReadings: [
+      { value: undefined, source: 'absent', key: 'CLOUDPIT_X' },
+      { value: undefined, source: 'absent', key: 'CLOUDPIT_X' },
+    ],
+  },
+];
+
+for (const arm of PARITY_ARMS) {
+  test(`parity ${arm.label}: the Electron reader matches the server reader`, () => {
+    const server = readWith(createServerBrandEnvReader, arm.env);
+    const electron = readWith(createElectronBrandEnvReader, arm.env);
+
+    const serverReadings = [server.read('X'), server.read('X')];
+    const electronReadings = [electron.read('X'), electron.read('X')];
+
+    assert.deepEqual(serverReadings, arm.expectedReadings, 'server implementation reads the arm');
+    assert.deepEqual(electronReadings, arm.expectedReadings, 'Electron implementation reads the arm');
+    assert.deepEqual(electronReadings, serverReadings, 'the two runtimes must return the same readings');
+  });
+}
+
+// ── Electron main: the control-plane resolver ──────────────────────────────
+
+const DEFAULT_CONTROL_PLANE_URL = 'https://cloudcli.ai';
+
+/** Resolve the control-plane URL through the same expression main.js binds. */
+function resolveControlPlaneUrl(env) {
+  return readBrandEnvValue(readWith(createElectronBrandEnvReader, env), 'CONTROL_PLANE_URL', DEFAULT_CONTROL_PLANE_URL);
+}
+
+test('Electron AC3: only CLOUDPIT_CONTROL_PLANE_URL set reads the new value', () => {
+  assert.equal(
+    resolveControlPlaneUrl({ CLOUDPIT_CONTROL_PLANE_URL: 'https://cloudpit.example' }),
+    'https://cloudpit.example',
+  );
+});
+
+test('Electron AC3 (v3.0): only CLOUDCLI_CONTROL_PLANE_URL set keeps the shipped default', () => {
+  assert.equal(
+    resolveControlPlaneUrl({ CLOUDCLI_CONTROL_PLANE_URL: 'https://legacy.example' }),
+    DEFAULT_CONTROL_PLANE_URL,
+    'the retired legacy spelling must not supply the control-plane address',
+  );
+});
+
+test('Electron AC3: both set means the new value wins', () => {
+  assert.equal(
+    resolveControlPlaneUrl({
+      CLOUDPIT_CONTROL_PLANE_URL: 'https://new.example',
+      CLOUDCLI_CONTROL_PLANE_URL: 'https://old.example',
+    }),
+    'https://new.example',
+  );
+});
+
+test('Electron AC4: no control-plane env keeps https://cloudcli.ai', () => {
+  assert.equal(resolveControlPlaneUrl({}), DEFAULT_CONTROL_PLANE_URL);
+});
+
+test('Electron wiring: main.js binds the reader and keeps the third-party default', () => {
+  const source = readRepoFile('electron/main.js');
+
+  assert.match(
+    source,
+    /readBrandEnvValue\(brandEnv, 'CONTROL_PLANE_URL', 'https:\/\/cloudcli\.ai'\)/,
+    'main.js must resolve the control plane through the brand reader',
+  );
+  assert.ok(
+    source.includes("'https://cloudcli.ai'"),
+    'the default control-plane address is a third-party contract and must stay',
+  );
+  assert.doesNotMatch(source, /process\.env\.CLOUDCLI_/, 'main.js must not read a legacy spelling directly');
+});
+
+// ── Electron localServer discovery ─────────────────────────────────────────
+
+const DEFAULT_LOCAL_SERVER_URL = 'http://127.0.0.1:3001';
+const NO_MARKERS = { markerPaths: [] };
+
+test('localServer AC3: only CLOUDPIT_DESKTOP_LOCAL_SERVER_URL is discovered first', async () => {
+  const reader = readWith(createElectronBrandEnvReader, {
+    CLOUDPIT_DESKTOP_LOCAL_SERVER_URL: 'http://127.0.0.1:4401',
+  });
+
+  const urls = await getExistingServerCandidateUrls(DEFAULT_LOCAL_SERVER_URL, { reader, ...NO_MARKERS });
+  assert.equal(urls[0], 'http://127.0.0.1:4401');
+});
+
+test('localServer AC3 (v3.0): a legacy-only discovery variable is ignored', async () => {
+  const reader = readWith(createElectronBrandEnvReader, {
+    CLOUDCLI_DESKTOP_LOCAL_SERVER_URL: 'http://127.0.0.1:4402',
+  });
+
+  const urls = await getExistingServerCandidateUrls(DEFAULT_LOCAL_SERVER_URL, { reader, ...NO_MARKERS });
+  assert.deepEqual(urls, [DEFAULT_LOCAL_SERVER_URL], 'the retired spelling must not add a candidate');
+});
+
+test('localServer AC3: both spellings set means the new address is the only candidate', async () => {
+  const reader = readWith(createElectronBrandEnvReader, {
+    CLOUDPIT_DESKTOP_LOCAL_SERVER_URL: 'http://127.0.0.1:4401',
+    CLOUDCLI_DESKTOP_LOCAL_SERVER_URL: 'http://127.0.0.1:4402',
+  });
+
+  const urls = await getExistingServerCandidateUrls(DEFAULT_LOCAL_SERVER_URL, { reader, ...NO_MARKERS });
+  assert.equal(urls[0], 'http://127.0.0.1:4401');
+  assert.equal(urls.includes('http://127.0.0.1:4402'), false);
+});
+
+test('localServer AC3: CLOUDPIT_SERVER_PORT supplies the port candidate', async () => {
+  const reader = readWith(createElectronBrandEnvReader, {
+    CLOUDPIT_SERVER_PORT: '4403',
+  });
+
+  const urls = await getExistingServerCandidateUrls(DEFAULT_LOCAL_SERVER_URL, { reader, ...NO_MARKERS });
+  assert.equal(urls.includes('http://127.0.0.1:4403'), true);
+});
+
+test('localServer AC4: no discovery env means only the default URL', async () => {
+  const reader = readWith(createElectronBrandEnvReader, {});
+
+  const urls = await getExistingServerCandidateUrls(DEFAULT_LOCAL_SERVER_URL, { reader, ...NO_MARKERS });
+  assert.deepEqual(urls, [DEFAULT_LOCAL_SERVER_URL]);
+});
+
+test('localServer (v3.0): CLOUDPIT_USE_INSTALLED_SERVER is read, the legacy spelling is ignored', () => {
+  const newOnly = readWith(createElectronBrandEnvReader, { CLOUDPIT_USE_INSTALLED_SERVER: '1' });
+  assert.equal(isInstalledServerRequested(newOnly), true);
+
+  const legacyOnly = readWith(createElectronBrandEnvReader, { CLOUDCLI_USE_INSTALLED_SERVER: '1' });
+  assert.equal(isInstalledServerRequested(legacyOnly), false, 'the retired spelling must not opt in');
+
+  const both = readWith(createElectronBrandEnvReader, {
+    CLOUDPIT_USE_INSTALLED_SERVER: '0',
+    CLOUDCLI_USE_INSTALLED_SERVER: '1',
+  });
+  assert.equal(isInstalledServerRequested(both), false, 'the new value wins');
+});
+
+test('Electron wiring: localServer.js reads discovery names through the brand reader', () => {
+  const source = readRepoFile('electron/localServer.js');
+
+  assert.ok(
+    source.includes("readBrandEnvValue(reader, name, undefined)"),
+    'discovery names must go through the brand reader',
+  );
+  assert.ok(
+    source.includes("readBrandEnvValue(reader, 'USE_INSTALLED_SERVER', '')"),
+    'the installed-server switch must go through the brand reader',
+  );
+  assert.doesNotMatch(source, /process\.env\.CLOUDCLI_/);
+});
+
+// ── serverInstaller ────────────────────────────────────────────────────────
+
+function installerWith(env) {
+  return new ServerInstaller({
+    version: '2.0.0',
+    platform: 'linux',
+    arch: 'x64',
+    env,
+  });
+}
+
+test('serverInstaller AC4: no brand env keeps the shipped bundle defaults', () => {
+  const installer = installerWith({});
+
+  assert.equal(installer.bundleBaseUrl, 'https://github.com/yaleh/cloudpit/releases/download');
+  assert.equal(installer.bundleReleaseTag, 'v2.0.0');
+  assert.equal(installer.installRoot, DEFAULT_INSTALL_ROOT);
+  assert.equal(installer.migrateLegacyInstall, true);
+});
+
+test('serverInstaller AC3: only CLOUDPIT_* set reads the new values', () => {
+  const installer = installerWith({
+    CLOUDPIT_SERVER_BUNDLE_URL: 'https://bundles.example/new',
+    CLOUDPIT_SERVER_BUNDLE_RELEASE_TAG: 'v9',
+    CLOUDPIT_SERVER_DIR: '/opt/cloudpit-new',
+  });
+
+  assert.equal(installer.bundleBaseUrl, 'https://bundles.example/new');
+  assert.equal(installer.bundleReleaseTag, 'v9');
+  assert.equal(installer.installRoot, '/opt/cloudpit-new');
+  assert.equal(installer.migrateLegacyInstall, false);
+});
+
+test('serverInstaller AC3 (v3.0): only CLOUDCLI_* set keeps the shipped values', () => {
+  const installer = installerWith({
+    CLOUDCLI_SERVER_BUNDLE_URL: 'https://bundles.example/old',
+    CLOUDCLI_SERVER_BUNDLE_RELEASE_TAG: 'v8',
+    CLOUDCLI_SERVER_DIR: '/opt/cloudcli-old',
+  });
+
+  assert.equal(installer.bundleBaseUrl, 'https://github.com/yaleh/cloudpit/releases/download');
+  assert.equal(installer.bundleReleaseTag, 'v2.0.0');
+  assert.equal(installer.installRoot, DEFAULT_INSTALL_ROOT);
+  assert.equal(installer.migrateLegacyInstall, true);
+});
+
+test('serverInstaller AC3: both spellings set means the new values win', () => {
+  const installer = installerWith({
+    CLOUDPIT_SERVER_BUNDLE_URL: 'https://bundles.example/new',
+    CLOUDCLI_SERVER_BUNDLE_URL: 'https://bundles.example/old',
+    CLOUDPIT_SERVER_BUNDLE_RELEASE_TAG: 'v9',
+    CLOUDCLI_SERVER_BUNDLE_RELEASE_TAG: 'v8',
+    CLOUDPIT_SERVER_DIR: '/opt/cloudpit-new',
+    CLOUDCLI_SERVER_DIR: '/opt/cloudcli-old',
+  });
+
+  assert.equal(installer.bundleBaseUrl, 'https://bundles.example/new');
+  assert.equal(installer.bundleReleaseTag, 'v9');
+  assert.equal(installer.installRoot, '/opt/cloudpit-new');
+});
+
+test('Electron wiring: serverInstaller.js reads bundle names through the brand reader', () => {
+  const source = readRepoFile('electron/serverInstaller.js');
+
+  assert.ok(source.includes('const brandEnv = createBrandEnvReader({ env })'));
+  assert.doesNotMatch(source, /process\.env\.CLOUDCLI_/);
+});

package/electron/tests/cloudpit-desktop-identity.test.mjs

@@ -5,9 +5,10 @@
  *   npx tsx --tsconfig server/tsconfig.json --test electron/tests/cloudpit-desktop-identity.test.mjs
  *
  * Covers the flipped display identity (`APP_NAME` / `productName`), the
- * one-time userData copy, the movable local-server cache, the new-then-legacy
- * marker lookup, dual deep-link scheme registration, and the pinned invariants
- * (`appId`, the `cloudcli://auth/callback` URL, `app_surface=cloudcli_desktop`).
+ * one-time userData copy (now owned by `appIdMigration.js`), the movable
+ * local-server cache, the new-then-legacy marker lookup, dual deep-link scheme
+ * registration, the v3.0 `appId` switch, and the pinned cloud-contract
+ * invariants (`cloudcli://auth/callback`, `app_surface=cloudcli_desktop`).
  * File operations use real temp directories; only the failing-rename arm
  * injects an `fs` whose `rename` rejects.
  */
@@ -75,8 +76,8 @@ test('AC2/AC7: main.js names the app Cloudpit while pinning the cloud identity',
   assert.match(source, /const APP_NAME = 'Cloudpit';/, 'APP_NAME is Cloudpit');
   assert.match(
     source,
-    /const APP_USER_MODEL_ID = 'ai\.cloudcli\.desktop';/,
-    'the Windows app user model id is unchanged',
+    /const APP_USER_MODEL_ID = 'ai\.cloudpit\.desktop';/,
+    'the Windows app user model id follows the v3.0 app id',
   );
   assert.match(source, /const CALLBACK_PROTOCOL = 'cloudcli';/, 'the cloud callback scheme is unchanged');
   assert.ok(
@@ -90,13 +91,13 @@ test('AC2/AC7: main.js names the app Cloudpit while pinning the cloud identity',
   );
 });
 
-test('AC3: bootstrap wires maybeMigrateDesktopUserData before app.whenReady()', () => {
+test('AC3: bootstrap wires the app-id migration (and its userData copy) before app.whenReady()', () => {
   const source = readFileSync(MAIN_SOURCE_PATH, 'utf8');
 
   assert.match(
     source,
-    /import \{ maybeMigrateDesktopUserData \} from '\.\/userDataMigration\.js';/,
-    'the migration helper is imported',
+    /import \{ maybeMigrateDesktopAppId \} from '\.\/appIdMigration\.js';/,
+    'the v3.0 app-id migration entry point is imported',
   );
 
   const bootstrapStart = source.indexOf('async function bootstrap()');
@@ -104,15 +105,24 @@ test('AC3: bootstrap wires maybeMigrateDesktopUserData before app.whenReady()',
   const bootstrapSource = source.slice(bootstrapStart, source.indexOf('\n}', bootstrapStart));
 
   const titleIndex = bootstrapSource.indexOf('process.title = APP_NAME');
-  const callIndex = bootstrapSource.indexOf('maybeMigrateDesktopUserData({');
+  const callIndex = bootstrapSource.indexOf('maybeMigrateDesktopAppId({');
   const readyIndex = bootstrapSource.indexOf('await app.whenReady()');
   assert.ok(titleIndex >= 0, 'the app name is assigned first');
   assert.ok(callIndex > titleIndex, 'migration runs after the app name is assigned');
   assert.ok(readyIndex > callIndex, 'migration runs before app.whenReady()');
 
   const callSource = bootstrapSource.slice(callIndex, readyIndex);
-  assert.match(callSource, /appName: APP_NAME,/, 'the call passes the flipped app name');
   assert.match(callSource, /appDataDir: app\.getPath\('appData'\)/, 'the call targets appData');
+
+  // appIdMigration owns the three-file userData copy and still goes through the
+  // shared, app-name-guarded helper.
+  const migrationSource = readFileSync(path.join(ELECTRON_DIR, '..', 'appIdMigration.js'), 'utf8');
+  assert.match(
+    migrationSource,
+    /import \{[^}]*maybeMigrateDesktopUserData[^}]*\} from '\.\/userDataMigration\.js';/,
+    'the app-id migration reuses the userData helper',
+  );
+  assert.match(migrationSource, /appName: DESKTOP_PRODUCT_NAME,/, 'the helper runs under the Cloudpit name');
 });
 
 test('AC2: package.json names the app Cloudpit', () => {
@@ -231,22 +241,27 @@ test('AC5: server/index.ts writes the marker under .cloudpit', () => {
   );
 });
 
-test('AC6: both deep-link schemes are registered in the packaged app metadata', () => {
+test('AC6: the packaged app metadata still claims both schemes (cloudcli stays for the auth callback)', () => {
   const pkg = readPackageJson();
 
+  // R5 retires the cloudcli DEEP LINK (main.js registers only cloudpit), but the
+  // third-party login callback `cloudcli://auth/callback` must still reach the
+  // app, so the OS-level declaration keeps the legacy scheme.
   const protocolSchemes = pkg.build.protocols.flatMap((protocol) => protocol.schemes);
-  assert.ok(protocolSchemes.includes('cloudcli'), 'build.protocols keeps cloudcli');
-  assert.ok(protocolSchemes.includes('cloudpit'), 'build.protocols adds cloudpit');
+  assert.ok(protocolSchemes.includes('cloudcli'), 'build.protocols keeps cloudcli for cloudcli://auth/callback');
+  assert.ok(protocolSchemes.includes('cloudpit'), 'build.protocols declares cloudpit');
 
   const macSchemes = pkg.build.mac.extendInfo.CFBundleURLTypes.flatMap((type) => type.CFBundleURLSchemes);
-  assert.ok(macSchemes.includes('cloudcli'), 'mac CFBundleURLSchemes keeps cloudcli');
-  assert.ok(macSchemes.includes('cloudpit'), 'mac CFBundleURLSchemes adds cloudpit');
+  assert.ok(macSchemes.includes('cloudcli'), 'mac CFBundleURLSchemes keeps cloudcli for the auth callback');
+  assert.ok(macSchemes.includes('cloudpit'), 'mac CFBundleURLSchemes declares cloudpit');
 });
 
-test('AC6: main.js registers both schemes in the dev and packaged branches', () => {
+test('AC6: main.js registers only the cloudpit deep link and still parses the cloudcli callback', () => {
   const source = readFileSync(MAIN_SOURCE_PATH, 'utf8');
 
-  assert.match(source, /const DEEP_LINK_SCHEMES = \['cloudcli', 'cloudpit'\];/);
+  assert.match(source, /const DEEP_LINK_SCHEMES = \['cloudpit'\];/);
+  assert.match(source, /const CALLBACK_PROTOCOL = 'cloudcli';/);
+  assert.match(source, /const CALLBACK_URL = `\$\{CALLBACK_PROTOCOL\}:\/\/auth\/callback`;/);
 
   const start = source.indexOf('function registerProtocolHandler()');
   assert.ok(start >= 0, 'registerProtocolHandler() exists');
@@ -263,11 +278,19 @@ test('AC6: main.js registers both schemes in the dev and packaged branches', ()
     /app\.setAsDefaultProtocolClient\(scheme\);/,
     'the packaged branch registers every scheme',
   );
+
+  // The cloudcli callback is still PARSED even though it is no longer registered
+  // as a deep link here; the OS association comes from build.protocols above.
+  const handleStart = source.indexOf('async function handleDeepLink(');
+  assert.ok(handleStart >= 0, 'handleDeepLink() exists');
+  const handleSource = source.slice(handleStart, source.indexOf('\n}', handleStart));
+  assert.match(handleSource, /parsed\.protocol !== `\$\{CALLBACK_PROTOCOL\}:`/);
+  assert.match(handleSource, /parsed\.hostname !== 'auth'/);
 });
 
-test('AC7: appId and the cloudcli_desktop surface are unchanged', () => {
+test('AC7: appId follows the v3.0 identity while the cloudcli_desktop surface is unchanged', () => {
   const pkg = readPackageJson();
-  assert.equal(pkg.build.appId, 'ai.cloudcli.desktop');
+  assert.equal(pkg.build.appId, 'ai.cloudpit.desktop');
 
   const cloudSource = readFileSync(CLOUD_SOURCE_PATH, 'utf8');
   assert.match(cloudSource, /app_surface', 'cloudcli_desktop'\)/);

package/electron/tests/cloudpit-runtime-identity-surfaces.test.mjs

@@ -23,9 +23,11 @@
  * by path, so a future edit cannot make the criterion self-red).
  *
  * The non-goal identity (`cloudcli.ai`, the `cloudcli://auth/callback` login
- * callback, `app_surface=cloudcli_desktop`, the `ai.cloudcli.desktop` app id and
- * the dual-read `cloudcli://` observation URIs) is asserted *present* in the
- * same run — a zero-hit scan must not be achieved by renaming it away.
+ * callback, `app_surface=cloudcli_desktop`, the legacy `ai.cloudcli.desktop`
+ * app-id spelling and the dual-read `cloudcli://` observation URIs) is asserted
+ * *present* in the same run — a zero-hit scan must not be achieved by renaming
+ * it away. (v3.0's R13 keeps that legacy spelling as the migration constant in
+ * `electron/appIdMigration.js`; the live `APP_USER_MODEL_ID` is the new id.)
  */
 import assert from 'node:assert/strict';
 import {
@@ -425,7 +427,11 @@ test('AC4: a tmp fixture holding only the non-goal cloudcli identifiers stays cl
 
 test('AC4: the live non-goal identity pins are untouched', () => {
   const mainSource = readRepoFile('electron/main.js');
-  assert.match(mainSource, /const APP_USER_MODEL_ID = 'ai\.cloudcli\.desktop';/, 'the app id is unchanged');
+  assert.match(
+    mainSource,
+    /const APP_USER_MODEL_ID = 'ai\.cloudpit\.desktop';/,
+    'the live app id follows the v3.0 switch (its legacy spelling is a non-goal token, not the live pin)',
+  );
   assert.match(mainSource, /const CALLBACK_PROTOCOL = 'cloudcli';/, 'the login callback scheme is unchanged');
   assert.ok(
     mainSource.includes('const CALLBACK_URL = `${CALLBACK_PROTOCOL}://auth/callback`;'),

package/electron/tests/cloudpit-userdata-migration.test.mjs

@@ -98,15 +98,28 @@ test('AC7: the CloudCLI app-name guard never touches the filesystem', (t) => {
   assert.equal(existsSync(path.join(newUserDataDir, 'cache.bin')), false);
 });
 
-test('AC7: electron/main.js imports and calls the helper and declares APP_NAME = Cloudpit', () => {
+test('AC7: main.js runs the app-id migration, which reuses the guarded helper under Cloudpit', () => {
   const source = readFileSync(MAIN_SOURCE_PATH, 'utf8');
 
   assert.match(
     source,
-    /import \{ maybeMigrateDesktopUserData \} from '\.\/userDataMigration\.js';/,
-    'the helper module is imported',
+    /import \{ maybeMigrateDesktopAppId \} from '\.\/appIdMigration\.js';/,
+    'the v3.0 app-id migration entry point is imported',
   );
-  assert.match(source, /maybeMigrateDesktopUserData\(\{/, 'the helper is called');
-  assert.match(source, /appName: APP_NAME,/, 'the call passes the flipped app name');
+  assert.match(source, /maybeMigrateDesktopAppId\(\{/, 'the migration is called from bootstrap()');
   assert.match(source, /const APP_NAME = 'Cloudpit';/, 'APP_NAME is flipped to Cloudpit');
+
+  // The three-file copy moved into the app-id migration in v3.0 but still goes
+  // through the shared helper (and therefore through its app-name guard).
+  const migrationSource = readFileSync(
+    fileURLToPath(new URL('../appIdMigration.js', import.meta.url)),
+    'utf8',
+  );
+  assert.match(
+    migrationSource,
+    /import \{[^}]*maybeMigrateDesktopUserData[^}]*\} from '\.\/userDataMigration\.js';/,
+    'appIdMigration imports the helper',
+  );
+  assert.match(migrationSource, /maybeMigrateDesktopUserData\(\{/, 'appIdMigration calls the helper');
+  assert.match(migrationSource, /appName: DESKTOP_PRODUCT_NAME,/, 'the helper runs under Cloudpit');
 });

package/electron/userDataMigration.js

@@ -24,6 +24,9 @@ export const DESKTOP_USER_DATA_FILES = [
 const LEGACY_APP_DATA_DIRECTORY_NAME = 'CloudCLI';
 const CLOUDPIT_APP_DATA_DIRECTORY_NAME = 'Cloudpit';
 
+/** Exported so the app-id migration can name the legacy rollback folder. */
+export const LEGACY_DESKTOP_USER_DATA_DIRECTORY = LEGACY_APP_DATA_DIRECTORY_NAME;
+
 /**
  * Copies the three desktop userData files from the CloudCLI folder into the
  * Cloudpit folder.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yalehwang/cloudpit",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "publishConfig": {
     "access": "public"
   },
@@ -44,6 +44,7 @@
     "desktop:dist:win": "npm run build && npm run desktop:stage && electron-builder --projectDir .desktop-build/desktop-app --win nsis",
     "server:bundle": "npm run build && node scripts/release/build-server-bundle.js",
     "desktop:icon:mac": "node electron/scripts/generate-macos-icon.js",
+    "desktop:icon:win": "node electron/scripts/generate-windows-icon.js",
     "build": "npm run build:client && npm run build:server",
     "build:client": "vite build && node scripts/write-client-build-info.mjs",
     "prebuild:server": "node -e \"require('node:fs').rmSync('dist-server.next', { recursive: true, force: true })\"",
@@ -72,7 +73,7 @@
     "update:platform": "./update-platform.sh"
   },
   "build": {
-    "appId": "ai.cloudcli.desktop",
+    "appId": "ai.cloudpit.desktop",
     "productName": "Cloudpit",
     "asar": false,
     "artifactName": "cloudpit-desktop-${version}-${os}-${arch}.${ext}",
@@ -94,7 +95,7 @@
     ],
     "protocols": [
       {
-        "name": "CloudCLI",
+        "name": "Cloudpit",
         "schemes": [
           "cloudcli"
         ]
@@ -114,11 +115,11 @@
         "dmg"
       ],
       "extendInfo": {
-        "CFBundleName": "CloudCLI",
-        "CFBundleDisplayName": "CloudCLI",
+        "CFBundleName": "Cloudpit",
+        "CFBundleDisplayName": "Cloudpit",
         "CFBundleURLTypes": [
           {
-            "CFBundleURLName": "CloudCLI",
+            "CFBundleURLName": "Cloudpit",
             "CFBundleURLSchemes": [
               "cloudcli",
               "cloudpit"

package/public/api-docs.html

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>CloudCLI - API Documentation</title>
+    <title>Cloudpit - API Documentation</title>
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="icon" type="image/png" href="/favicon.png" />
 
@@ -151,7 +151,7 @@
                     </svg>
                 </div>
                 <div class="brand-text">
-                    <h1>CloudCLI</h1>
+                    <h1>Cloudpit</h1>
                     <div class="subtitle">API Documentation</div>
                 </div>
             </div>
@@ -167,7 +167,7 @@
     <main>
         <h2>API Documentation</h2>
         <p>
-            CloudCLI runs a local HTTP server that serves its web interface. This page
+            Cloudpit runs a local HTTP server that serves its web interface. This page
             is the place for documentation of the HTTP API that server exposes.
         </p>