@harborclient/sdk 1.0.0 → 1.0.1

package/dist/runtime/index.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, it, jest } from '@jest/globals';
-import { defineTheme, registerTheme } from './index.js';
-/**
- * Builds a minimal plugin context mock for registerTheme tests.
- */
-function createMockPluginContext() {
-    const disposable = { dispose: jest.fn() };
-    const registerMock = jest.fn(() => disposable);
-    const subscriptions = [];
-    return {
-        subscriptions,
-        themes: { register: registerMock },
-        registerMock
-    };
-}
-describe('registerTheme', () => {
-    it('registers the theme, pushes the disposable onto subscriptions, and returns it', () => {
-        const hc = createMockPluginContext();
-        const theme = {
-            id: 'solarized',
-            title: 'Solarized Dark',
-            type: 'dark',
-            colors: { surface: '#002b36' }
-        };
-        const disposable = registerTheme(hc, theme);
-        expect(hc.registerMock).toHaveBeenCalledWith(theme);
-        expect(hc.subscriptions).toHaveLength(1);
-        expect(hc.subscriptions[0]).toBe(disposable);
-    });
-});
-describe('defineTheme', () => {
-    it('returns the theme argument unchanged', () => {
-        const theme = {
-            id: 'nord',
-            title: 'Nord',
-            type: 'dark',
-            stylesheet: 'dist/theme.css'
-        };
-        expect(defineTheme(theme)).toBe(theme);
-    });
-});

package/dist/runtime/index.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it, jest } from '@jest/globals';
-import type { PluginContext, ThemeContribution } from '../types';
-import { defineTheme, registerTheme } from './index.js';
-
-/**
- * Builds a minimal plugin context mock for registerTheme tests.
- */
-function createMockPluginContext(): PluginContext & {
-  registerMock: jest.MockedFunction<PluginContext['themes']['register']>;
-} {
-  const disposable = { dispose: jest.fn() };
-  const registerMock = jest.fn(() => disposable);
-  const subscriptions: PluginContext['subscriptions'] = [];
-
-  return {
-    subscriptions,
-    themes: { register: registerMock },
-    registerMock
-  } as unknown as PluginContext & {
-    registerMock: jest.MockedFunction<PluginContext['themes']['register']>;
-  };
-}
-
-describe('registerTheme', () => {
-  it('registers the theme, pushes the disposable onto subscriptions, and returns it', () => {
-    const hc = createMockPluginContext();
-    const theme: ThemeContribution = {
-      id: 'solarized',
-      title: 'Solarized Dark',
-      type: 'dark',
-      colors: { surface: '#002b36' }
-    };
-
-    const disposable = registerTheme(hc, theme);
-
-    expect(hc.registerMock).toHaveBeenCalledWith(theme);
-    expect(hc.subscriptions).toHaveLength(1);
-    expect(hc.subscriptions[0]).toBe(disposable);
-  });
-});
-
-describe('defineTheme', () => {
-  it('returns the theme argument unchanged', () => {
-    const theme: ThemeContribution = {
-      id: 'nord',
-      title: 'Nord',
-      type: 'dark',
-      stylesheet: 'dist/theme.css'
-    };
-
-    expect(defineTheme(theme)).toBe(theme);
-  });
-});

package/dist/runtime-utils.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=runtime-utils.test.d.ts.map

package/dist/runtime-utils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime-utils.test.d.ts","sourceRoot":"","sources":["../src/runtime-utils.test.ts"],"names":[],"mappings":""}

package/dist/runtime-utils.test.js

@@ -1,177 +0,0 @@
-import { afterEach, describe, expect, it, jest } from '@jest/globals';
-import { byteLength, createLogger, randomId, truncateBody, truncateToBytes } from './runtime-utils.js';
-const originalTextEncoder = globalThis.TextEncoder;
-const originalCrypto = globalThis.crypto;
-afterEach(() => {
-    globalThis.TextEncoder = originalTextEncoder;
-    globalThis.crypto = originalCrypto;
-    jest.restoreAllMocks();
-});
-function withoutTextEncoder(run) {
-    // @ts-expect-error — exercise manual UTF-8 fallback used in SES main runtime
-    globalThis.TextEncoder = undefined;
-    return run();
-}
-describe('randomId', () => {
-    it('returns a UUID when crypto.randomUUID is available', () => {
-        const spy = jest
-            .spyOn(globalThis.crypto, 'randomUUID')
-            .mockReturnValue('00000000-0000-4000-8000-000000000000');
-        expect(randomId()).toBe('00000000-0000-4000-8000-000000000000');
-        spy.mockRestore();
-    });
-    it('falls back to a prefixed id when randomUUID is unavailable', () => {
-        // @ts-expect-error — exercise SES main-runtime fallback
-        globalThis.crypto = undefined;
-        expect(randomId('req')).toMatch(/^req-\d+-[a-z0-9]+$/);
-    });
-    it('uses the default prefix in the fallback path', () => {
-        // @ts-expect-error — exercise SES main-runtime fallback
-        globalThis.crypto = undefined;
-        expect(randomId()).toMatch(/^id-\d+-[a-z0-9]+$/);
-    });
-});
-describe('byteLength', () => {
-    it('counts ASCII as one byte per character', () => {
-        expect(byteLength('abc')).toBe(3);
-        expect(byteLength('')).toBe(0);
-    });
-    it('counts two-byte UTF-8 characters', () => {
-        expect(byteLength('é')).toBe(2);
-    });
-    it('counts three-byte UTF-8 characters', () => {
-        expect(byteLength('中')).toBe(3);
-    });
-    it('counts surrogate pairs as four bytes', () => {
-        expect(byteLength('😀')).toBe(4);
-    });
-    it('matches TextEncoder when the manual fallback is used', () => {
-        const samples = ['plain', 'é', '中', '😀', 'mix é 中 😀'];
-        for (const sample of samples) {
-            const encodedLength = new originalTextEncoder().encode(sample).length;
-            withoutTextEncoder(() => {
-                expect(byteLength(sample)).toBe(encodedLength);
-            });
-        }
-    });
-});
-describe('truncateToBytes', () => {
-    it('returns the original string when it fits', () => {
-        expect(truncateToBytes('hello', 10)).toBe('hello');
-        expect(truncateToBytes('é', 2)).toBe('é');
-    });
-    it('truncates multibyte text without splitting code units', () => {
-        expect(truncateToBytes('éé', 2)).toBe('é');
-        expect(truncateToBytes('abc', 2)).toBe('ab');
-    });
-    it('returns an empty string when maxBytes is zero', () => {
-        expect(truncateToBytes('hello', 0)).toBe('');
-    });
-    it('excludes an incomplete surrogate pair in the manual fallback', () => {
-        withoutTextEncoder(() => {
-            expect(truncateToBytes('a😀b', 2)).toBe('a');
-        });
-    });
-    it('does not split multibyte characters in the manual fallback', () => {
-        withoutTextEncoder(() => {
-            expect(truncateToBytes('mix é end', 5)).toBe('mix ');
-            expect(truncateToBytes('中文字', 3)).toBe('中');
-        });
-    });
-});
-describe('truncateBody', () => {
-    it('returns the body unchanged when within the byte limit', () => {
-        expect(truncateBody('{"ok":true}', 100)).toEqual({
-            body: '{"ok":true}',
-            truncated: false
-        });
-    });
-    it('truncates and appends the default suffix when over the limit', () => {
-        const body = 'x'.repeat(20);
-        const maxBytes = 10;
-        const result = truncateBody(body, maxBytes);
-        expect(result.truncated).toBe(true);
-        expect(result.body.endsWith(`[truncated — body exceeded ${maxBytes} bytes]`)).toBe(true);
-        expect(byteLength(result.body.replace(/\n\n\[truncated — body exceeded \d+ bytes\]$/, ''))).toBeLessThanOrEqual(maxBytes);
-    });
-    it('uses a custom suffix when provided', () => {
-        const result = truncateBody('0123456789', 5, '…');
-        expect(result).toEqual({
-            body: '01234…',
-            truncated: true
-        });
-    });
-});
-describe('createLogger', () => {
-    it('prefixes messages with [pluginId]', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const logger = createLogger('my-plugin');
-        logger.info('hello');
-        expect(logSpy).toHaveBeenCalledWith('[my-plugin]', 'hello');
-        logSpy.mockRestore();
-    });
-    it('filters messages below the active level', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-        const logger = createLogger('my-plugin', { level: 'warn' });
-        logger.debug('hidden');
-        logger.info('hidden');
-        logger.warn('visible');
-        expect(logSpy).not.toHaveBeenCalled();
-        expect(warnSpy).toHaveBeenCalledTimes(1);
-        expect(warnSpy).toHaveBeenCalledWith('[my-plugin]', 'visible');
-        logSpy.mockRestore();
-        warnSpy.mockRestore();
-    });
-    it('updates the active level via setLevel', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const logger = createLogger('my-plugin');
-        logger.info('before');
-        logger.setLevel('silent');
-        logger.info('after');
-        expect(logSpy).toHaveBeenCalledTimes(1);
-        expect(logSpy).toHaveBeenCalledWith('[my-plugin]', 'before');
-        logSpy.mockRestore();
-    });
-    it('suppresses all output at silent level', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-        const logger = createLogger('my-plugin', { level: 'silent' });
-        logger.debug('a');
-        logger.info('b');
-        logger.warn('c');
-        logger.error('d');
-        expect(logSpy).not.toHaveBeenCalled();
-        expect(errorSpy).not.toHaveBeenCalled();
-        logSpy.mockRestore();
-        errorSpy.mockRestore();
-    });
-    it('routes warn and error through console.warn and console.error when available', () => {
-        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-        const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-        const logger = createLogger('my-plugin', { level: 'debug' });
-        logger.warn('warned');
-        logger.error('failed');
-        expect(warnSpy).toHaveBeenCalledWith('[my-plugin]', 'warned');
-        expect(errorSpy).toHaveBeenCalledWith('[my-plugin]', 'failed');
-        warnSpy.mockRestore();
-        errorSpy.mockRestore();
-    });
-    it('falls back to console.log when console.warn and console.error are unavailable', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const originalWarn = console.warn;
-        const originalError = console.error;
-        // @ts-expect-error — exercise SES main-runtime fallback
-        console.warn = undefined;
-        // @ts-expect-error — exercise SES main-runtime fallback
-        console.error = undefined;
-        const logger = createLogger('my-plugin', { level: 'debug' });
-        logger.warn('warned');
-        logger.error('failed');
-        expect(logSpy).toHaveBeenCalledWith('[my-plugin]', 'warned');
-        expect(logSpy).toHaveBeenCalledWith('[my-plugin]', 'failed');
-        console.warn = originalWarn;
-        console.error = originalError;
-        logSpy.mockRestore();
-    });
-});

package/dist/signing/signing.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=signing.test.d.ts.map

package/dist/signing/signing.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"signing.test.d.ts","sourceRoot":"","sources":["../../src/signing/signing.test.ts"],"names":[],"mappings":""}

package/dist/signing/signing.test.js

@@ -1,100 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { signPlugin } from './sign.js';
-import { createTestPluginDir, createTestSigningKeys } from './testFixtures.js';
-import { verifyPlugin } from './verify.js';
-describe('signPlugin', () => {
-    it('writes signature.json for a valid plugin directory', async () => {
-        const keys = createTestSigningKeys();
-        const fixture = createTestPluginDir();
-        try {
-            const result = await signPlugin({
-                pluginDir: fixture.pluginDir,
-                privateKeyPem: keys.privateKeyPem,
-                keyId: 'test-key'
-            });
-            expect(result.signature.pluginId).toBe('com.example.test-plugin');
-            expect(result.signature.pluginVersion).toBe('1.0.0');
-            expect(result.signature.keyId).toBe('test-key');
-            expect(result.signature.files.map((file) => file.path)).toEqual([
-                'dist/renderer.js',
-                'manifest.json'
-            ]);
-            const verification = await verifyPlugin({
-                pluginDir: fixture.pluginDir,
-                trustedPublicKeysPem: [keys.publicKeyPem]
-            });
-            expect(verification.status).toBe('valid');
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-    it('rejects invalid private keys', async () => {
-        const fixture = createTestPluginDir();
-        try {
-            await expect(signPlugin({
-                pluginDir: fixture.pluginDir,
-                privateKeyPem: 'not-a-key'
-            })).rejects.toThrow(/invalid ed25519 private key/i);
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-});
-describe('verifyPlugin', () => {
-    it('returns unsigned when signature.json is absent', async () => {
-        const fixture = createTestPluginDir();
-        try {
-            const result = await verifyPlugin({
-                pluginDir: fixture.pluginDir,
-                trustedPublicKeysPem: [createTestSigningKeys().publicKeyPem]
-            });
-            expect(result.status).toBe('unsigned');
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-    it('returns invalid when a signed file is tampered with', async () => {
-        const keys = createTestSigningKeys();
-        const fixture = createTestPluginDir();
-        try {
-            await signPlugin({
-                pluginDir: fixture.pluginDir,
-                privateKeyPem: keys.privateKeyPem
-            });
-            writeFileSync(join(fixture.pluginDir, 'dist', 'renderer.js'), 'export function activate() { return 1; }');
-            const result = await verifyPlugin({
-                pluginDir: fixture.pluginDir,
-                trustedPublicKeysPem: [keys.publicKeyPem]
-            });
-            expect(result.status).toBe('invalid');
-            expect(result.error).toMatch(/signed inventory/i);
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-    it('returns invalid when verified with the wrong public key', async () => {
-        const keys = createTestSigningKeys();
-        const otherKeys = createTestSigningKeys();
-        const fixture = createTestPluginDir();
-        try {
-            await signPlugin({
-                pluginDir: fixture.pluginDir,
-                privateKeyPem: keys.privateKeyPem
-            });
-            const result = await verifyPlugin({
-                pluginDir: fixture.pluginDir,
-                trustedPublicKeysPem: [otherKeys.publicKeyPem]
-            });
-            expect(result.status).toBe('invalid');
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-});

package/dist/storage/cappedList.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cappedList.test.d.ts.map

package/dist/storage/cappedList.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cappedList.test.d.ts","sourceRoot":"","sources":["../../src/storage/cappedList.test.ts"],"names":[],"mappings":""}

package/dist/storage/cappedList.test.js

@@ -1,11 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { mergeById } from './cappedList.js';
-describe('mergeById', () => {
-    it('dedupes and caps newest-first', () => {
-        const merged = mergeById([{ id: 'b' }, { id: 'a' }], [{ id: 'a' }, { id: 'c' }], {
-            cap: 3,
-            idOf: (entry) => entry.id
-        });
-        expect(merged.map((entry) => entry.id)).toEqual(['b', 'a', 'c']);
-    });
-});

package/dist/storage/validate.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=validate.test.d.ts.map

package/dist/storage/validate.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.test.d.ts","sourceRoot":"","sources":["../../src/storage/validate.test.ts"],"names":[],"mappings":""}

package/dist/storage/validate.test.js

@@ -1,78 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { arrayOf, asRecord, bool, isRecord, num, numArray, oneOf, recordOf, str, strArray } from './validate.js';
-describe('isRecord', () => {
-    it('accepts plain objects and rejects arrays and primitives', () => {
-        expect(isRecord({ a: 1 })).toBe(true);
-        expect(isRecord([])).toBe(false);
-        expect(isRecord(null)).toBe(false);
-        expect(isRecord('x')).toBe(false);
-    });
-});
-describe('asRecord', () => {
-    it('returns the record or null', () => {
-        const value = { key: 'v' };
-        expect(asRecord(value)).toBe(value);
-        expect(asRecord(null)).toBeNull();
-        expect(asRecord([1])).toBeNull();
-    });
-});
-describe('str', () => {
-    it('returns strings and falls back otherwise', () => {
-        expect(str('hello', '')).toBe('hello');
-        expect(str(42, 'fallback')).toBe('fallback');
-        expect(str(undefined, null)).toBeNull();
-    });
-});
-describe('num', () => {
-    it('returns finite numbers and falls back otherwise', () => {
-        expect(num(3, 0)).toBe(3);
-        expect(num(NaN, 0)).toBe(0);
-        expect(num(Infinity, 0)).toBe(0);
-        expect(num('3', null)).toBeNull();
-    });
-});
-describe('bool', () => {
-    it('returns booleans and falls back otherwise', () => {
-        expect(bool(true, false)).toBe(true);
-        expect(bool(false, true)).toBe(false);
-        expect(bool('true', true)).toBe(true);
-    });
-});
-describe('oneOf', () => {
-    it('accepts allowed literals and falls back otherwise', () => {
-        expect(oneOf('delay', ['interval', 'delay'], 'interval')).toBe('delay');
-        expect(oneOf('other', ['interval', 'delay'], 'interval')).toBe('interval');
-        expect(oneOf(1, ['interval', 'delay'], 'interval')).toBe('interval');
-    });
-});
-describe('numArray', () => {
-    it('filters to finite numbers', () => {
-        expect(numArray([1, NaN, 2, 'x', Infinity])).toEqual([1, 2]);
-        expect(numArray(null)).toEqual([]);
-    });
-});
-describe('strArray', () => {
-    it('filters to strings', () => {
-        expect(strArray(['a', 1, 'b'])).toEqual(['a', 'b']);
-        expect(strArray(undefined)).toEqual([]);
-    });
-});
-describe('arrayOf', () => {
-    it('filters through a guard', () => {
-        const isNum = (entry) => typeof entry === 'number' && Number.isFinite(entry);
-        expect(arrayOf([1, 'x', 2], isNum)).toEqual([1, 2]);
-        expect(arrayOf('nope', isNum)).toEqual([]);
-    });
-});
-describe('recordOf', () => {
-    it('keeps entries that pass the guard', () => {
-        const isNum = (entry) => typeof entry === 'number' && Number.isFinite(entry);
-        expect(recordOf({
-            a: 1,
-            b: 'x',
-            c: 2
-        }, isNum)).toEqual({ a: 1, c: 2 });
-        expect(recordOf([], isNum)).toEqual({});
-        expect(recordOf(null, isNum)).toEqual({});
-    });
-});

package/dist/store.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=store.test.d.ts.map

package/dist/store.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.test.d.ts","sourceRoot":"","sources":["../src/store.test.ts"],"names":[],"mappings":""}