serverless-ircd 0.5.0 → 0.7.0

package/apps/web/tests/build-env.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_CONFIG_FILE, ENV_TO_CONFIG_FILE, resolveConfigFile } from '../src/build-env';
+
+// ============================================================================
+// resolveConfigFile — per-env config selection
+// ============================================================================
+
+describe('resolveConfigFile', () => {
+  it('selects config.staging.json for --env staging', () => {
+    const result = resolveConfigFile(['--env', 'staging']);
+    expect(result.file).toBe('config.staging.json');
+    expect(result.env).toBe('staging');
+  });
+
+  it('selects config.prod.json for --env prod', () => {
+    const result = resolveConfigFile(['--env', 'prod']);
+    expect(result.file).toBe('config.prod.json');
+    expect(result.env).toBe('prod');
+  });
+
+  it('falls back to the default config (staging target) when --env is absent', () => {
+    const result = resolveConfigFile([]);
+    expect(result.file).toBe(DEFAULT_CONFIG_FILE);
+    expect(result.file).toBe('config.json');
+    expect(result.env).toBe('default (staging)');
+  });
+
+  it('throws on an unknown --env value', () => {
+    expect(() => resolveConfigFile(['--env', 'local'])).toThrowError(/Unknown --env value: local/u);
+  });
+
+  it("throws on a typo'd env value", () => {
+    expect(() => resolveConfigFile(['--env', 'production'])).toThrowError(
+      /Unknown --env value: production/u,
+    );
+    expect(() => resolveConfigFile(['--env', 'stg'])).toThrowError(/Unknown --env value: stg/u);
+  });
+
+  it('names the accepted env values in the error message', () => {
+    try {
+      resolveConfigFile(['--env', 'nope']);
+      expect.fail('expected resolveConfigFile to throw');
+    } catch (err) {
+      const msg = (err as Error).message;
+      // Every accepted key is listed so the operator knows the valid set.
+      for (const key of Object.keys(ENV_TO_CONFIG_FILE)) {
+        expect(msg).toContain(key);
+      }
+    }
+  });
+
+  it('ignores unrelated argv flags', () => {
+    const result = resolveConfigFile(['--verbose', '--env', 'prod', '--dry-run']);
+    expect(result.file).toBe('config.prod.json');
+  });
+
+  it('treats a missing value after --env as undefined (falls back to default)', () => {
+    // `--env` with no following arg: argv.indexOf('--env') + 1 yields
+    // `undefined`, which hits the "no flag" branch.
+    const result = resolveConfigFile(['--env']);
+    expect(result.file).toBe(DEFAULT_CONFIG_FILE);
+  });
+});

package/apps/web/tests/build-smoke.test.ts

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { parseKiwiConfig } from '../src/config-schema';
+
+const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const appDist = path.join(pkgRoot, 'dist', 'app');
+const indexPath = path.join(appDist, 'index.html');
+const landingSrc = path.join(pkgRoot, 'landing', 'index.html');
+const landingDist = path.join(pkgRoot, 'dist', 'index.html');
+
+// Validates the output of `pnpm --filter web build` (or `build:staging` /
+// `build:prod`). Skipped until the SPA has been built (the Kiwi upstream
+// build is too heavy to run inside the test suite); run the build first to
+// exercise these assertions.
+const built = existsSync(indexPath);
+// The landing page is copied by the same build script but is an independent
+// artifact; gate the build-output assertion on its own presence.
+const landingBuilt = existsSync(landingDist) && statSync(landingDist).size > 0;
+
+describe.skipIf(!built)('Kiwi SPA build output (dist/app/)', () => {
+  it('emits dist/app/index.html', () => {
+    expect(existsSync(indexPath)).toBe(true);
+  });
+
+  it('layers a schema-valid static/config.json into dist/app/static/config.json', () => {
+    const configPath = path.join(appDist, 'static', 'config.json');
+    expect(existsSync(configPath)).toBe(true);
+    // The baked config must clear the Zod schema no matter which --env was
+    // selected at build time.
+    const cfg = parseKiwiConfig(JSON.parse(readFileSync(configPath, 'utf8')));
+    expect(cfg.windowTitle.length).toBeGreaterThan(0);
+    expect(cfg.startupOptions.channel.startsWith('#')).toBe(true);
+  });
+
+  it('prefixes every asset reference with /app/', () => {
+    const html = readFileSync(indexPath, 'utf8');
+    // No bare relative `static/...` references may remain.
+    const bareStaticRefs = html.match(/(?:src|href)=["']static\//g) ?? [];
+    expect(bareStaticRefs).toEqual([]);
+    // At least one asset must be /app/-prefixed (the main bundle).
+    const appPrefixed = html.match(/(?:src|href)=["']\/app\/static\//g) ?? [];
+    expect(appPrefixed.length).toBeGreaterThan(0);
+  });
+
+  it('ships a hashed JS bundle under dist/app/static/js/', () => {
+    const jsDir = path.join(appDist, 'static', 'js');
+    expect(existsSync(jsDir)).toBe(true);
+    const js = readdirSync(jsDir).filter((f) => f.endsWith('.js'));
+    expect(js.length).toBeGreaterThan(0);
+  });
+});
+
+// The landing page is a static file with no compilation step — the build
+// copies it verbatim to dist/index.html. Validating the source directly means
+// these assertions run in CI without the (heavy) Kiwi build; the build-output
+// describe below verifies the copy is wired up.
+describe('landing page source (landing/index.html)', () => {
+  it('exists as a non-empty HTML document', () => {
+    expect(existsSync(landingSrc)).toBe(true);
+    const html = readFileSync(landingSrc, 'utf8');
+    expect(html.length).toBeGreaterThan(0);
+    expect(html).toContain('<!doctype html>');
+    expect(html).toContain('<title>');
+  });
+
+  it('links to the IRC client at /app/', () => {
+    const html = readFileSync(landingSrc, 'utf8');
+    expect(html).toMatch(/href=["']\/app\/?["']/);
+  });
+
+  it('links to the project docs', () => {
+    const html = readFileSync(landingSrc, 'utf8');
+    expect(html).toMatch(/href=["'][^"']*docs\/?["']/);
+  });
+
+  it('links to the source repository', () => {
+    const html = readFileSync(landingSrc, 'utf8');
+    expect(html.toLowerCase()).toMatch(/github\.com/);
+  });
+
+  it('is responsive (declares a viewport meta tag)', () => {
+    const html = readFileSync(landingSrc, 'utf8');
+    expect(html).toMatch(/<meta[^>]+name=["']viewport["']/);
+  });
+
+  it('works without JavaScript (no <script> tags — pure static HTML/CSS)', () => {
+    const html = readFileSync(landingSrc, 'utf8');
+    // The landing page is the project's front door and must render fully
+    // without JS (acceptance: "works without JS").
+    const scriptTags = html.match(/<script\b/gi) ?? [];
+    expect(scriptTags).toEqual([]);
+  });
+});
+
+describe.skipIf(!landingBuilt)('landing page build output (dist/index.html)', () => {
+  it('is a verbatim copy of landing/index.html', () => {
+    const src = readFileSync(landingSrc, 'utf8');
+    const dist = readFileSync(landingDist, 'utf8');
+    expect(dist).toBe(src);
+  });
+});

package/apps/web/tests/config-schema.test.ts

@@ -0,0 +1,432 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { KiwiConfigSchema, parseKiwiConfig } from '../src/config-schema';
+
+const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const staticDir = path.join(pkgRoot, 'static');
+
+function readStaticConfig(name: string): unknown {
+  return JSON.parse(readFileSync(path.join(staticDir, name), 'utf8'));
+}
+
+// A minimal valid startupOptions payload, extended per test. `direct` + `tls`
+// are included because the Worker is a direct IRC-over-WebSocket server (not
+// a kiwiServer WebIRC gateway), so every real config MUST set both; the
+// schema makes them required to prevent the kiwiServer-gateway regression.
+function validStartupOptions(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    server: '{{hostname}}',
+    direct: true,
+    tls: true,
+    channel: '#welcome',
+    ...overrides,
+  };
+}
+
+function validConfig(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    windowTitle: 'ServerlessIRCd',
+    startupOptions: validStartupOptions(),
+    ...overrides,
+  };
+}
+
+// ============================================================================
+// KiwiConfigSchema — required fields (TDD outline: Red #1 — Zod accepts `{}`)
+// ============================================================================
+
+describe('KiwiConfigSchema — required fields', () => {
+  it('rejects an empty object (missing windowTitle + startupOptions)', () => {
+    expect(() => parseKiwiConfig({})).toThrowError(/Invalid Kiwi web config/u);
+  });
+
+  it('rejects a config missing startupOptions', () => {
+    expect(() => parseKiwiConfig({ windowTitle: 'ServerlessIRCd' })).toThrowError(
+      /startupOptions/u,
+    );
+  });
+
+  it('rejects a config missing windowTitle', () => {
+    expect(() => parseKiwiConfig({ startupOptions: validStartupOptions() })).toThrowError(
+      /windowTitle/u,
+    );
+  });
+
+  it('rejects an empty windowTitle', () => {
+    expect(() =>
+      parseKiwiConfig({ windowTitle: '', startupOptions: validStartupOptions() }),
+    ).toThrowError(/windowTitle/u);
+  });
+
+  it('rejects startupOptions missing server (TDD outline #1)', () => {
+    expect(() =>
+      parseKiwiConfig({ windowTitle: 'x', startupOptions: { channel: '#welcome' } }),
+    ).toThrowError(/server/u);
+  });
+
+  it('rejects startupOptions with an empty server', () => {
+    expect(() =>
+      parseKiwiConfig({
+        windowTitle: 'x',
+        startupOptions: { server: '', channel: '#welcome' },
+      }),
+    ).toThrowError(/server/u);
+  });
+
+  it('rejects startupOptions missing channel', () => {
+    expect(() =>
+      parseKiwiConfig({ windowTitle: 'x', startupOptions: { server: 'irc.x' } }),
+    ).toThrowError(/channel/u);
+  });
+});
+
+// ============================================================================
+// KiwiConfigSchema — port range (TDD outline: Red #3 — `port: 99999` passes)
+// ============================================================================
+
+describe('KiwiConfigSchema — port range', () => {
+  it('rejects a port above 65535 (TDD outline #3)', () => {
+    expect(() =>
+      parseKiwiConfig(
+        validConfig({
+          startupOptions: validStartupOptions({ port: 99999 }),
+        }),
+      ),
+    ).toThrowError(/port/u);
+  });
+
+  it('rejects port 0', () => {
+    expect(() =>
+      parseKiwiConfig(
+        validConfig({
+          startupOptions: validStartupOptions({ port: 0 }),
+        }),
+      ),
+    ).toThrowError(/port/u);
+  });
+
+  it('rejects a negative port', () => {
+    expect(() =>
+      parseKiwiConfig(
+        validConfig({
+          startupOptions: validStartupOptions({ port: -1 }),
+        }),
+      ),
+    ).toThrowError(/port/u);
+  });
+
+  it('rejects a non-integer port', () => {
+    expect(() =>
+      parseKiwiConfig(
+        validConfig({
+          startupOptions: validStartupOptions({ port: 6667.5 }),
+        }),
+      ),
+    ).toThrowError(/port/u);
+  });
+
+  it('accepts port 1 (lower bound)', () => {
+    const cfg = parseKiwiConfig(
+      validConfig({
+        startupOptions: validStartupOptions({ port: 1 }),
+      }),
+    );
+    expect(cfg.startupOptions.port).toBe(1);
+  });
+
+  it('accepts port 65535 (upper bound)', () => {
+    const cfg = parseKiwiConfig(
+      validConfig({
+        startupOptions: validStartupOptions({ port: 65535 }),
+      }),
+    );
+    expect(cfg.startupOptions.port).toBe(65535);
+  });
+});
+
+// ============================================================================
+// KiwiConfigSchema — channel prefix (TDD outline: Red #5 — `channels: ["foo"]`)
+// ============================================================================
+
+describe('KiwiConfigSchema — channel prefix', () => {
+  it('rejects a channel without the # prefix (TDD outline #5)', () => {
+    expect(() =>
+      parseKiwiConfig(
+        validConfig({
+          startupOptions: validStartupOptions({ channel: 'welcome' }),
+        }),
+      ),
+    ).toThrowError(/channel/u);
+  });
+
+  it('rejects an empty channel', () => {
+    expect(() =>
+      parseKiwiConfig(
+        validConfig({
+          startupOptions: validStartupOptions({ channel: '' }),
+        }),
+      ),
+    ).toThrowError(/channel/u);
+  });
+
+  it('accepts a single # channel', () => {
+    const cfg = parseKiwiConfig(validConfig());
+    expect(cfg.startupOptions.channel).toBe('#welcome');
+  });
+
+  it('accepts a comma-separated channel list when each starts with #', () => {
+    const cfg = parseKiwiConfig(
+      validConfig({
+        startupOptions: validStartupOptions({ channel: '#a,#b' }),
+      }),
+    );
+    expect(cfg.startupOptions.channel).toBe('#a,#b');
+  });
+});
+
+// ============================================================================
+// KiwiConfigSchema — direct WebSocket mode (bypass the kiwiServer gateway)
+// ============================================================================
+//
+// Kiwi has two connection modes (upstream `src/libs/IrcClient.js:69-82`):
+//   • `direct: false` (the Kiwi default) → routes the IRC connection through
+//     a server-side WebIRC gateway at `kiwiServer` (default `/webirc/kiwiirc/`)
+//     via the ServerSession control channel. The browser first probes
+//     `${kiwiServer}/info`; if nothing serves it (our Worker doesn't), the
+//     SPA logs a 404 and cannot connect.
+//   • `direct: true` → the browser opens a WebSocket straight to
+//     `startupOptions.server` (irc-framework's default transport), which is
+//     exactly what our Worker serves at `/`.
+//
+// The Worker is NOT a kiwiServer gateway, so every shipped config MUST set
+// `direct: true` (and `tls: true`, since Cloudflare terminates HTTPS and the
+// WS upgrade must be `wss://`). The schema makes both required so a config
+// that regresses to gateway mode fails the build rather than 404-ing at
+// runtime.
+
+describe('KiwiConfigSchema — direct WebSocket mode', () => {
+  it('rejects startupOptions missing direct (would fall back to the kiwiServer gateway and 404)', () => {
+    expect(() =>
+      parseKiwiConfig(
+        validConfig({
+          startupOptions: { server: '{{hostname}}', tls: true, channel: '#welcome' },
+        }),
+      ),
+    ).toThrowError(/direct/u);
+  });
+
+  it('rejects startupOptions missing tls (Cloudflare serves HTTPS; the WS must be wss://)', () => {
+    expect(() =>
+      parseKiwiConfig(
+        validConfig({
+          startupOptions: { server: '{{hostname}}', direct: true, channel: '#welcome' },
+        }),
+      ),
+    ).toThrowError(/tls/u);
+  });
+
+  it('accepts direct: true with tls: true', () => {
+    const cfg = parseKiwiConfig(validConfig());
+    expect(cfg.startupOptions.direct).toBe(true);
+    expect(cfg.startupOptions.tls).toBe(true);
+  });
+});
+
+// ============================================================================
+// KiwiConfigSchema — WS path (direct_path)
+// ============================================================================
+//
+// NOTE: Kiwi reads `startupOptions.direct_path`, NOT `startupOptions.path`
+// (upstream `src/helpers/Misc.js:139`: `connection.direct_path = config.direct_path || ''`).
+// The Worker accepts WS upgrades at `/` (root), so `direct_path` — when
+// supplied — MUST be `/`. It is optional: an empty/absent value lets
+// irc-framework build `wss://host:port` with no path, which the browser
+// normalises to `wss://host:port/` and the Worker accepts.
+
+describe('KiwiConfigSchema — WS path (direct_path)', () => {
+  it('rejects a direct_path other than / (WS endpoint is at root)', () => {
+    expect(() =>
+      parseKiwiConfig(
+        validConfig({
+          startupOptions: validStartupOptions({ direct_path: '/app/' }),
+        }),
+      ),
+    ).toThrowError(/direct_path/u);
+  });
+
+  it('accepts the / direct_path', () => {
+    const cfg = parseKiwiConfig(
+      validConfig({
+        startupOptions: validStartupOptions({ direct_path: '/' }),
+      }),
+    );
+    expect(cfg.startupOptions.direct_path).toBe('/');
+  });
+
+  it('accepts an absent direct_path (irc-framework omits the path; browser defaults to /)', () => {
+    const cfg = parseKiwiConfig(validConfig());
+    expect(cfg.startupOptions.direct_path).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// KiwiConfigSchema — passthrough of Kiwi-specific fields
+// ============================================================================
+
+describe('KiwiConfigSchema — passthrough', () => {
+  it('preserves unknown top-level Kiwi fields (themes, plugins, embedly)', () => {
+    const input = validConfig({
+      theme: 'Dark',
+      themes: [{ name: 'Dark', url: 'static/themes/dark' }],
+      embedly: { key: '' },
+      plugins: [{ name: 'customise', url: 'static/plugins/customise.html' }],
+    });
+    const cfg = parseKiwiConfig(input);
+    expect(cfg).toHaveProperty('theme', 'Dark');
+    expect(cfg).toHaveProperty('embedly');
+  });
+
+  it('preserves unknown startupOptions fields (nick, startupScreen)', () => {
+    const input = validConfig({
+      startupScreen: 'welcome',
+      startupOptions: validStartupOptions({ nick: 'guest-?' }),
+    });
+    const cfg = parseKiwiConfig(input);
+    expect(cfg).toHaveProperty('startupScreen', 'welcome');
+    expect(cfg.startupOptions).toHaveProperty('nick', 'guest-?');
+  });
+});
+
+// ============================================================================
+// parseKiwiConfig — error formatting
+// ============================================================================
+
+describe('parseKiwiConfig — error formatting', () => {
+  it('throws a single aggregated Error listing every invalid field', () => {
+    try {
+      parseKiwiConfig({
+        windowTitle: '',
+        startupOptions: { server: '', port: 99999, channel: 'x' },
+      });
+      expect.fail('expected parseKiwiConfig to throw');
+    } catch (err) {
+      expect(err).toBeInstanceOf(Error);
+      const msg = String((err as Error).message);
+      expect(msg).toMatch(/Invalid Kiwi web config/u);
+      // Aggregated: every offending field is named.
+      expect(msg).toMatch(/windowTitle/u);
+      expect(msg).toMatch(/server/u);
+      expect(msg).toMatch(/port/u);
+      expect(msg).toMatch(/channel/u);
+    }
+  });
+
+  it('rejects non-object inputs', () => {
+    expect(() => parseKiwiConfig('hello')).toThrowError(/Invalid Kiwi web config/u);
+    expect(() => parseKiwiConfig(null)).toThrowError(/Invalid Kiwi web config/u);
+    expect(() => parseKiwiConfig([])).toThrowError(/Invalid Kiwi web config/u);
+  });
+});
+
+// ============================================================================
+// KiwiConfigSchema — server auto-detect ({{hostname}} template)
+// ============================================================================
+//
+// Kiwi registers a value-replacement pass on every page load (upstream
+// `src/main.js`: `addValueReplacement('hostname', window.location.hostname)`
+// et al.) that substitutes `{{hostname}}` / `{{host}}` / `{{port}}` in any
+// config string at browser load time. Baking `{{hostname}}` into
+// `startupOptions.server` therefore makes the SPA connect to whatever host
+// the Worker served it from — staging, prod, preview, PR deployment — without
+// a per-env hostname baked at build time. This is the deploy-time resolution
+// path; the schema accepts (but no longer requires) a literal hostname so an
+// operator can still pin one for bespoke deployments.
+
+describe('KiwiConfigSchema — server auto-detect ({{hostname}} template)', () => {
+  it('accepts the {{hostname}} template (Kiwi resolves it to window.location.hostname)', () => {
+    const cfg = parseKiwiConfig(
+      validConfig({ startupOptions: validStartupOptions({ server: '{{hostname}}' }) }),
+    );
+    expect(cfg.startupOptions.server).toBe('{{hostname}}');
+  });
+
+  it('accepts the {{host}} template (includes port when non-default)', () => {
+    const cfg = parseKiwiConfig(
+      validConfig({ startupOptions: validStartupOptions({ server: '{{host}}' }) }),
+    );
+    expect(cfg.startupOptions.server).toBe('{{host}}');
+  });
+
+  it('still accepts a literal hostname (operator pins a specific target)', () => {
+    const cfg = parseKiwiConfig(
+      validConfig({ startupOptions: validStartupOptions({ server: 'irc.example.com' }) }),
+    );
+    expect(cfg.startupOptions.server).toBe('irc.example.com');
+  });
+});
+
+// ============================================================================
+// Static config files — per-env build matrix
+// ============================================================================
+
+describe('static config files', () => {
+  it('config.json parses (default = staging target)', () => {
+    const cfg = parseKiwiConfig(readStaticConfig('config.json'));
+    expect(cfg.startupOptions.server.length).toBeGreaterThan(0);
+    expect(cfg.startupOptions.channel.startsWith('#')).toBe(true);
+  });
+
+  it('config.staging.json parses', () => {
+    const cfg = parseKiwiConfig(readStaticConfig('config.staging.json'));
+    expect(cfg.startupOptions.channel.startsWith('#')).toBe(true);
+  });
+
+  it('config.prod.json parses', () => {
+    const cfg = parseKiwiConfig(readStaticConfig('config.prod.json'));
+    expect(cfg.startupOptions.channel.startsWith('#')).toBe(true);
+  });
+
+  it('the raw schema also accepts every static config', () => {
+    expect(KiwiConfigSchema.safeParse(readStaticConfig('config.json')).success).toBe(true);
+    expect(KiwiConfigSchema.safeParse(readStaticConfig('config.staging.json')).success).toBe(true);
+    expect(KiwiConfigSchema.safeParse(readStaticConfig('config.prod.json')).success).toBe(true);
+  });
+
+  // Deploy-time resolution: every shipped config uses the {{hostname}} template
+  // so the browser resolves `server` from window.location.hostname at load
+  // time. This is the whole point of NOT baking a per-env hostname; if any
+  // config regresses to a literal host, this assertion fires.
+  it('every static config bakes {{hostname}} for server (deploy-time auto-detect)', () => {
+    for (const file of ['config.json', 'config.staging.json', 'config.prod.json']) {
+      const cfg = parseKiwiConfig(readStaticConfig(file));
+      expect(cfg.startupOptions.server, `${file} server`).toBe('{{hostname}}');
+    }
+  });
+
+  // The Worker is a direct IRC-over-WebSocket server, NOT a kiwiServer WebIRC
+  // gateway. Every shipped config MUST set direct:true + tls:true so Kiwi
+  // opens a wss:// WebSocket straight to the Worker instead of probing the
+  // (non-existent) /webirc/kiwiirc/info gateway endpoint and 404-ing.
+  it('every static config sets direct:true + tls:true (no kiwiServer gateway)', () => {
+    for (const file of ['config.json', 'config.staging.json', 'config.prod.json']) {
+      const cfg = parseKiwiConfig(readStaticConfig(file));
+      expect(cfg.startupOptions.direct, `${file} direct`).toBe(true);
+      expect(cfg.startupOptions.tls, `${file} tls`).toBe(true);
+    }
+  });
+
+  // Upstream Kiwi ships `static/plugins/customise.html.example` (a template),
+  // not `customise.html`. Referencing the un-served `.html` path — which the
+  // upstream default config also does — produces a 404 + console error on
+  // every page load. We don't customise Kiwi, so no static config may ship a
+  // `plugins` block. If plugin support is ever needed, the build must copy
+  // `.example` → `.html` (or ship a real plugin file) first.
+  it('no static config ships a plugins block (avoids the customise.html 404)', () => {
+    for (const file of ['config.json', 'config.staging.json', 'config.prod.json']) {
+      const raw = readStaticConfig(file) as Record<string, unknown>;
+      expect(raw.plugins, `${file} plugins`).toBeUndefined();
+    }
+  });
+});

package/apps/web/tests/workspace.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+import pkg from '../package.json' with { type: 'json' };
+
+describe('apps/web workspace skeleton', () => {
+  it('exposes the @serverless-ircd/web package name', () => {
+    expect(pkg.name).toBe('@serverless-ircd/web');
+  });
+
+  it('reserves a build task that the workspace can run', () => {
+    expect(typeof pkg.scripts?.build).toBe('string');
+  });
+});

package/apps/web/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node"],
+    "composite": false
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["dist"]
+}

package/apps/web/upstream/.browserslistrc

@@ -0,0 +1,3 @@
+> 1%
+last 2 versions
+not ie <= 8

package/apps/web/upstream/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 4
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true

package/apps/web/upstream/.eslintignore

@@ -0,0 +1,3 @@
+build/*.js
+config/*.js
+tests/unit/coverage/