Release v2.2.5

Author: gbro3n

vs-code-extension/package.json

@@ -2,7 +2,7 @@
     "name": "as-notes",
     "displayName": "AS Notes - Personal Knowledge Management System (PKMS)",
     "description": "VS Code Personal Knowledge Management System (PKMS) - Markdown Editing, Wikilinks (inc. Nested), Tasks, Kanban, Files, Publish to HTML, Daily Journal, Encrypted Notes",
-    "version": "2.2.4",
+    "version": "2.2.5",
     "publisher": "appsoftwareltd",
     "license": "Elastic-2.0",
     "icon": "images/icon.png",

vs-code-extension/src/LicenceActivationService.ts

@@ -12,11 +12,13 @@
  *   5. A periodic background validation (POST /api/v1/licence/validate)
  *      runs every 24 hours to detect revocation.
  *
- * ## Grace period
+ * ## Offline fallback
  *
- *   When the server is unreachable, the extension falls back to the
- *   cached token state for up to 7 days from the last successful
- *   validation. After that, pro features are disabled.
+ *   When the server is unreachable, the extension falls back to a
+ *   format-based check: if the licence key matches the ASNO-XXXX format
+ *   regex, Pro Editor access is granted with `serverUnreachable: true`.
+ *   This is a temporary measure until cryptographic offline keys are
+ *   implemented.
  */
 
 import * as vscode from 'vscode';
@@ -36,7 +38,6 @@ const SECRET_LAST_VALIDATED = 'as-notes.lastValidated';
 const SECRET_LICENCE_STATE = 'as-notes.licenceState';
 
 const DEFAULT_BASE_URL = 'https://www.asnotes.io';
-const GRACE_PERIOD_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 
 const MAX_RETRIES = 3;
 const RETRY_DELAYS_MS = [1_000, 4_000, 16_000];
@@ -95,6 +96,7 @@ async function fetchWithRetry(
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(body),
+                signal: AbortSignal.timeout(10_000),
             });
             // Only retry on 5xx
             if (response.status >= 500 && attempt < MAX_RETRIES) {
@@ -238,8 +240,8 @@ export async function activateWithServer(
         throw new Error(`Unexpected status ${response.status}`);
 
     } catch (err) {
-        // Server unreachable or all retries exhausted — apply grace period
-        return applyGracePeriod(persisted);
+        // Server unreachable or all retries exhausted — fall back to format check
+        return applyFormatFallback(context.secrets, key);
     }
 }
 
@@ -293,29 +295,26 @@ export async function validateWithServer(
         throw new Error(`Unexpected status ${response.status}`);
 
     } catch {
-        // Server unreachable — apply grace period
-        return applyGracePeriod(persisted);
+        // Server unreachable — fall back to format check on persisted key
+        return applyFormatFallback(context.secrets, persisted.key ?? '');
     }
 }
 
-// ── Grace period ───────────────────────────────────────────────────────────
+// ── Offline format fallback ─────────────────────────────────────────────────
 
-function applyGracePeriod(persisted: {
-    token: string | undefined;
-    lastValidated: number | undefined;
-    state: LicenceState | undefined;
-}): LicenceState {
-    if (!persisted.token || !persisted.lastValidated || !persisted.state) {
-        return { ...defaultLicenceState(), serverUnreachable: true };
-    }
-
-    const elapsed = Date.now() - persisted.lastValidated;
-    if (elapsed <= GRACE_PERIOD_MS) {
-        // Within grace period — maintain current state
-        return { ...persisted.state, serverUnreachable: true };
+/**
+ * When the server is unreachable, grant Pro Editor access if the key
+ * passes the ASNO-XXXX-XXXX-XXXX-XXXX format check. This is a temporary
+ * fallback until cryptographic offline keys are implemented.
+ *
+ * Persists the resulting state to SecretStorage so it survives restarts.
+ */
+async function applyFormatFallback(secrets: vscode.SecretStorage, key: string): Promise<LicenceState> {
+    if (validateLicenceKeyFormat(key) === 'valid') {
+        const state: LicenceState = { status: 'valid', product: 'pro_editor', serverUnreachable: true };
+        await persistLicenceState(secrets, '', key, state);
+        return state;
     }
-
-    // Grace period exceeded
     return { ...defaultLicenceState(), serverUnreachable: true };
 }
 

vs-code-extension/src/extension.ts

@@ -505,7 +505,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<{ exte
             () => activateWithServer(key, context).then((state) => {
                 const wasValid = hasProEditorAccess(licenceState);
                 licenceState = state;
-                if (licenceState.serverUnreachable) {
+                if (licenceState.serverUnreachable && licenceState.status !== 'valid') {
                     showServerUnreachableWarning();
                 } else if (licenceState.status === 'invalid' || licenceState.status === 'not-entered') {
                     showLicenceWarning();

vs-code-extension/src/test/LicenceActivationService.test.ts

@@ -167,17 +167,8 @@ describe('activateWithServer', () => {
         vi.unstubAllGlobals();
     });
 
-    it('applies grace period when server is unreachable and within 7 days', async () => {
+    it('falls back to regex: returns pro_editor when server unreachable and key format is valid', async () => {
         vi.useFakeTimers({ shouldAdvanceTime: true });
-        const now = Date.now();
-        const token = buildTestJwt({
-            product: 'pro_editor',
-            exp: pastUnix(1), // expired
-        });
-        mockSecrets.set('as-notes.activationToken', token);
-        mockSecrets.set('as-notes.licenceKey', VALID_KEY);
-        mockSecrets.set('as-notes.lastValidated', (now - 2 * 86_400_000).toString()); // 2 days ago
-        mockSecrets.set('as-notes.licenceState', JSON.stringify({ status: 'valid', product: 'pro_editor' }));
 
         vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network error')));
 
@@ -187,29 +178,28 @@ describe('activateWithServer', () => {
         const result = await resultPromise;
         expect(result.status).toBe('valid');
         expect(result.product).toBe('pro_editor');
+        expect(result.serverUnreachable).toBe(true);
+
+        // Verify state was persisted
+        expect(mockSecrets.get('as-notes.licenceKey')).toBe(VALID_KEY);
+        const persisted = JSON.parse(mockSecrets.get('as-notes.licenceState')!);
+        expect(persisted.status).toBe('valid');
+        expect(persisted.product).toBe('pro_editor');
 
         vi.unstubAllGlobals();
         vi.useRealTimers();
     });
 
-    it('returns not-entered when grace period exceeded', async () => {
+    it('falls back to regex: returns not-entered when server unreachable and key format is invalid', async () => {
         vi.useFakeTimers({ shouldAdvanceTime: true });
-        const now = Date.now();
-        const token = buildTestJwt({
-            product: 'pro_editor',
-            exp: pastUnix(1),
-        });
-        mockSecrets.set('as-notes.activationToken', token);
-        mockSecrets.set('as-notes.licenceKey', VALID_KEY);
-        mockSecrets.set('as-notes.lastValidated', (now - 8 * 86_400_000).toString()); // 8 days ago
-        mockSecrets.set('as-notes.licenceState', JSON.stringify({ status: 'valid', product: 'pro_editor' }));
 
         vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network error')));
 
-        const resultPromise = activateWithServer(VALID_KEY, buildContext() as any);
+        const resultPromise = activateWithServer('ASNO-ZZZZ-ZZZZ-ZZZZ-ZZZZ', buildContext() as any);
         await vi.advanceTimersByTimeAsync(25_000);
         const result = await resultPromise;
-        expect(result.status).toBe('not-entered'); // falls back to default
+        // Invalid format returns 'invalid' before reaching the server, so this never hits the fallback
+        expect(result.status).toBe('invalid');
         expect(result.product).toBeNull();
 
         vi.unstubAllGlobals();
@@ -284,13 +274,12 @@ describe('validateWithServer', () => {
         vi.unstubAllGlobals();
     });
 
-    it('applies grace period when server unreachable during validation', async () => {
+    it('falls back to regex: returns pro_editor when server unreachable during validation', async () => {
         vi.useFakeTimers({ shouldAdvanceTime: true });
-        const now = Date.now();
         const token = buildTestJwt({ product: 'pro_editor', exp: futureUnix(365) });
         mockSecrets.set('as-notes.activationToken', token);
         mockSecrets.set('as-notes.licenceKey', VALID_KEY);
-        mockSecrets.set('as-notes.lastValidated', (now - 86_400_000).toString()); // 1 day ago
+        mockSecrets.set('as-notes.lastValidated', (Date.now() - 86_400_000).toString());
         mockSecrets.set('as-notes.licenceState', JSON.stringify({ status: 'valid', product: 'pro_editor' }));
 
         vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network error')));
@@ -300,8 +289,36 @@ describe('validateWithServer', () => {
         const result = await resultPromise;
         expect(result.status).toBe('valid');
         expect(result.product).toBe('pro_editor');
+        expect(result.serverUnreachable).toBe(true);
+
+        // Verify state was persisted
+        const persisted = JSON.parse(mockSecrets.get('as-notes.licenceState')!);
+        expect(persisted.status).toBe('valid');
+        expect(persisted.product).toBe('pro_editor');
 
         vi.unstubAllGlobals();
         vi.useRealTimers();
     });
+
+    it('persisted fallback state survives restart via loadCachedLicenceState', async () => {
+        vi.useFakeTimers({ shouldAdvanceTime: true });
+
+        vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network error')));
+
+        // Activate with server unreachable — fallback persists state
+        const activatePromise = activateWithServer(VALID_KEY, buildContext() as any);
+        await vi.advanceTimersByTimeAsync(25_000);
+        const result = await activatePromise;
+        expect(result.status).toBe('valid');
+
+        vi.unstubAllGlobals();
+        vi.useRealTimers();
+
+        // Simulate restart: load cached state (no server call)
+        const { loadCachedLicenceState } = await import('../LicenceActivationService.js');
+        const cachedState = await loadCachedLicenceState(buildContext() as any);
+        expect(cachedState.status).toBe('valid');
+        expect(cachedState.product).toBe('pro_editor');
+        expect(cachedState.serverUnreachable).toBe(true);
+    });
 });