• Meteor CLI must be installed: curl https://install.meteor.com/ | sh
• MongoDB 6.x or 7.x must be available (local or Atlas)
• Node.js 20.x LTS is required (Meteor pins the version internally)
• For the Rspack/webpack jade loader (npm-packages/meteor-jade-loader), the loader resolves Blaze/Spacebars compiler packages at runtime; those must be available via the Meteor package system, not npm directly.

Project setup

1. Clone / drop source: Place source/ at your project root or a subdirectory. If subdirectory, add a root package.json that symlinks or workspaces to source/.

2. Install Meteor: Run curl https://install.meteor.com/ | sh and confirm meteor --version matches the .meteor/release file inside source/.

3. Install npm deps: Inside source/, run:

   cd source
   meteor npm install
   

4. Configure environment: Copy source/settings.json to source/settings.local.json and fill in:

   {
     "public": { "CARD_OPENED_WEBHOOK_ENABLED": false },
     "MAIL_URL": "smtp://user:pass@smtp.example.com:587",
     "MONGO_URL": "mongodb://localhost:27017/wekan"
   }
   

5. Set environment variables:

   export MONGO_URL=mongodb://localhost:27017/wekan
   export ROOT_URL=http://localhost:4000
   export PORT=4000
   

6. Run:

   meteor run --settings settings.local.json
   

7. Rspack build (for non-Meteor bundling of client assets only):

   npx rspack build --config rspack.config.js
   

   The local npm packages under npm-packages/ must be resolvable; add them to package.json as file: references.

8. TypeScript / Babel: WeKan is plain JS. No tsconfig is needed unless you add TypeScript on top. Babel is used internally via @babel/parser; no separate .babelrc is required for running via Meteor.

Public API

TAPi18n

import { TAPi18n } from '/imports/i18n/index.js';

interface TAPi18n {
  init(): Promise<void>;
  __( key: string, ...args: any[] ): string;
}

TAPi18n is the internationalization singleton. Call TAPi18n.init() once inside Meteor.startup (already wired in imports/i18n/index.js). Use TAPi18n.__('key') anywhere in templates or JS to look up a translated string. Do not call init() more than once; the module guards against double initialization.

getGlobal

// npm-packages/meteor-globals-client/index.js
function getGlobal(packageName: string, globalName?: string): any;

getGlobal is a client-safe shim for reading Meteor package globals at runtime without pulling in Node.js built-ins. Use it when you need access to a Meteor package export (e.g., getGlobal('aldeed:simple-schema', 'SimpleSchema')) from inside a browser-facing module. Returns undefined safely if the package is not loaded.

checkMeteor

function checkMeteor(): boolean;

Returns true unconditionally in the client shim (npm-packages/meteor-globals-client). Used as a guard in @wekanteam/meteor-reactive-cache to skip server-only initialization paths when running in a browser or test environment. Useful when writing isomorphic utilities that depend on Meteor being present.

meteorJadeLoader (Rspack/webpack loader)

// npm-packages/meteor-jade-loader/index.js
// webpack/rspack loader — no named export; referenced by path in config
function meteorJadeLoader(this: LoaderContext, source: string): string;

A Rspack/webpack loader that compiles .jade Blaze templates to JavaScript. Wire it in rspack.config.js for any .jade file. It detects .tpl.jade (template mode) vs. plain .jade (file/body mode) automatically and emits Template.__checkName / new Template(...) registration code.

Working examples

Scenario - Bootstrap i18n in a Meteor startup hook

You want to add translated strings to a server-side method or a client component using the shared i18n module.

// server/myFeature.js  (or client/myFeature.js — isomorphic)
import { Meteor } from 'meteor/meteor';
import { TAPi18n } from '/imports/i18n/index.js';

Meteor.startup(async () => {
  // TAPi18n.init() is already called by imports/i18n/index.js on startup.
  // Just use __ directly after startup completes.
  const label = TAPi18n.__('due-date'); // key from imports/i18n/data/en.i18n.json
  console.log('Translated label:', label);
});

Scenario - Reading a Meteor package global from a browser module

You are writing a client utility that conditionally uses a Meteor package but must not crash if it is absent.

// client/lib/myUtil.js
import { getGlobal, checkMeteor } from '/npm-packages/meteor-globals-client/index.js';

export function getSimpleSchema() {
  if (!checkMeteor()) {
    throw new Error('Not running inside Meteor');
  }
  // Returns the SimpleSchema constructor exposed by the Atmosphere package
  return getGlobal('aldeed:simple-schema', 'SimpleSchema');
}

export function getBlazeTemplate(name: string) {
  const Template = getGlobal('blaze', 'Template');
  return Template ? Template[name] : null;
}

Scenario - Registering the jade loader in Rspack config

You want to bundle WeKan client components via Rspack outside the standard Meteor build.

// rspack.config.js  (extend or replace the existing one in source/)
const path = require('path');

module.exports = {
  entry: './client/main.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'bundle.js',
  },
  module: {
    rules: [
      {
        test: /\.jade$/,
        use: [
          {
            // Point at the local package directly
            loader: path.resolve(__dirname, 'npm-packages/meteor-jade-loader/index.js'),
          },
        ],
      },
      {
        test: /\.css$/,
        use: ['style-loader', 'css-loader'],
      },
    ],
  },
  resolve: {
    alias: {
      // Remap meteor/ imports to stubs when running outside Meteor
      'meteor/meteor': path.resolve(__dirname, 'stubs/meteor.js'),
    },
  },
};

File walkthrough

• client/main.js - Client entry point; imports collection helpers, all styles, then all application code in explicit order.
• client/features/main.js - Aggregates all Blaze jade templates, JS controllers, and CSS for main UI features (header, popup, editor, spinners, etc.).
• imports/i18n/index.js - Exports TAPi18n and calls TAPi18n.init() inside Meteor.startup; the canonical i18n bootstrap.
• npm-packages/meteor-globals-client/index.js - Client-safe shim for @wekanteam/meteor-globals; exports getGlobal, checkMeteor, ensureDependency, ensureDependencies.
• npm-packages/meteor-jade-loader/index.js - Rspack/webpack loader that compiles .jade Blaze templates to JS; auto-detects template vs. body mode.
• models/ - MongoDB collection schemas and helpers for all domain entities (boards, lists, cards, users, swimlanes, etc.).
• server/ - Meteor server publications, methods, REST API routes, and server-only utilities.
• migrations/ - Sequential database migration scripts run at startup via percolate:migrations.
• openapi/ - YAML/JSON OpenAPI 3.x specs describing the WeKan REST API endpoints.
• packages/ - Bundled Atmosphere packages that are not available on the public Atmosphere registry.
• public/ - Static assets served directly: fonts, favicons, PWA manifest.
• config/ - App-level configuration loaded at startup (OAuth providers, feature flags).
• rspack.config.js - Rspack bundler configuration for client-side asset compilation outside Meteor.
• docker-compose.yml - Canonical production deployment: wekan-app + wekan-db (MongoDB) services.
• settings.json - Template for Meteor --settings file; contains SMTP, S3, LDAP, and OAuth keys.

Common pitfalls and fixes

• meteor/ imports fail in plain Node/Rspack: Meteor package imports (meteor/meteor, meteor/blaze) don't resolve outside the Meteor build system. Fix: add webpack/rspack aliases pointing to stub files for each meteor/* package you need.
• SimpleSchema used on client crashes: imports/collectionHelpers notes that SimpleSchema is server-only. Fix: guard any schema usage with Meteor.isServer or use getGlobal from the client shim instead.
• TAPi18n.init() called before Meteor.startup: Translations won't load. Fix: always call or await TAPi18n.init() inside Meteor.startup(async () => { ... }) as shown in imports/i18n/index.js.
• Jade loader can't find Spacebars compiler: The loader calls require('./lib/jade-compiler') which expects Spacebars/HTML packages available at build time. Fix: run meteor npm install inside source/ before invoking Rspack so the local node_modules are populated.
• MongoDB connection drops causing data corruption: WeKan's README explicitly warns that running out of disk space corrupts MongoDB. Fix: set disk usage alerts and ensure MONGO_URL points to a replica set with journaling enabled.
• Wrong Node.js version: Meteor embeds its own Node.js but if you run scripts directly the system Node must be 20.x. Fix: use nvm use 20 or pin engines.node in your root package.json.

Vibe-coding prompt template

I have a local copy of the WeKan Open Source Kanban source at `./source/`
and a USAGE.md integration guide at `./USAGE.md`.
The upstream package is `user@example.com`.

My existing project is a Node.js/Express backend (or Meteor app).

Please help me integrate WeKan step by step:

1. Read USAGE.md and source/package.json to understand all required dependencies.
2. Install all runtime npm dependencies listed in USAGE.md into my project.
3. Wire the `source/imports/i18n/index.js` TAPi18n export into my startup sequence,
   following the pattern in USAGE.md "Bootstrap i18n" example.
4. Configure rspack.config.js (using source/npm-packages/meteor-jade-loader) to
   bundle the client components from source/client/main.js.
5. Set up environment variables MONGO_URL, ROOT_URL, PORT, and a settings.json
   based on source/settings.json.
6. Show me how to use getGlobal from source/npm-packages/meteor-globals-client
   to safely access a Meteor package export in a browser module.
7. Identify any meteor/ import aliases I need to stub for non-Meteor bundling.

Refer only to exports and patterns visible in source/ and described in USAGE.md.
Do not invent APIs.

License and credit

WeKan is released under the MIT License. See source/LICENSE for the full text.

Upstream project: WeKan on GitHub — user@example.com. Maintained by the WeKan Team; community translations hosted at Transifex.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.

Automation, Utilities & Developer Tools

$6