dsh-scheduled-message 0.1.1

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "dsh-scheduled-message",
+  "version": "0.1.1",
+  "description": "Schedule the message you are writing to send later, or turn it into a repeating automation task.",
+  "license": "MIT",
+  "author": "intelfabs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intelfabs/dsh-scheduled-message.git"
+  },
+  "homepage": "https://github.com/intelfabs/dsh-scheduled-message#readme",
+  "bugs": {
+    "url": "https://github.com/intelfabs/dsh-scheduled-message/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "icon": "icon.svg",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "lib",
+    "locale",
+    "docs",
+    "scripts",
+    "cordis.patch.yml",
+    "icon.svg",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "deepseek-harness",
+    "dsh-plugin",
+    "dsh",
+    "cordis",
+    "schedule",
+    "scheduled-message"
+  ],
+  "engines": {
+    "dsh": ">=0.2.2-rc.2"
+  },
+  "scripts": {
+    "build": "node scripts/build-client.mjs",
+    "test": "node --test test/core.test.mjs test/client.test.mjs test/host.test.mjs",
+    "check": "node scripts/check.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true
+    }
+  }
+}

package/scripts/build-client.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * Build the browser bundle `client.js` from its three sources.
+ *
+ * The Client half is one lazily materialized CJS factory, so it cannot import
+ * `lib/core.js` or read `locale/*.json` at runtime. This script inlines both
+ * into `client.src.js`'s factory: `core` stays the single implementation of the
+ * date, 12-hour clock and RRULE logic, and the dictionaries keep one source of
+ * truth. `test/client.test.mjs` rebuilds in memory and fails when the committed
+ * bundle differs, so the artifact can never drift from its sources.
+ *
+ * @module dsh-scheduled-message/scripts/build-client
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
+const PACKAGE_NAME = 'dsh-scheduled-message'
+
+/**
+ * Read one package-relative file.
+ * @param relative - path below the package root.
+ * @returns the file text.
+ */
+function read(relative) {
+  return readFileSync(join(ROOT, relative), 'utf8')
+}
+
+/**
+ * Turn `lib/core.js` into a factory-local module object.
+ * @returns source for one `const core = (() => { … })()` expression.
+ */
+function coreBlock() {
+  const source = read('lib/core.js')
+  const names = [...source.matchAll(/^export (?:const|function|class)\s+([A-Za-z_$][\w$]*)/gm)].map(match => match[1])
+  if (names.length === 0) throw new Error('lib/core.js exports nothing to inline')
+  if (/^export\s+(?!const|function|class)/m.test(source)) {
+    throw new Error('lib/core.js uses an export form the bundler cannot inline')
+  }
+  const body = source.replace(/^export\s+/gm, '')
+  return `const core = (() => {\n${body}\nreturn { ${names.join(', ')} }\n})()`
+}
+
+/**
+ * Turn both dictionaries into factory-local constants.
+ * @returns source declaring `EN` and `ZH`.
+ */
+function localeBlock() {
+  const en = JSON.parse(read('locale/en.json'))
+  const zh = JSON.parse(read('locale/zh.json'))
+  const missing = Object.keys(en).filter(key => !(key in zh))
+  const extra = Object.keys(zh).filter(key => !(key in en))
+  if (missing.length > 0 || extra.length > 0) {
+    throw new Error(`locale key mismatch: en-only ${JSON.stringify(missing)}, zh-only ${JSON.stringify(extra)}`)
+  }
+  return `const EN = ${JSON.stringify(en, null, 2)}\n\nconst ZH = ${JSON.stringify(zh, null, 2)}`
+}
+
+/**
+ * Compose the whole bundle text.
+ * @returns the `client.js` artifact.
+ */
+export function buildClient() {
+  const source = read('client.src.js')
+  if (!/^export function createClientPlugin\(require\) \{/m.test(source)) {
+    throw new Error('client.src.js must export exactly one createClientPlugin factory')
+  }
+  const plugin = source.replace(/^export function createClientPlugin\(require\) \{/m, 'function createClientPlugin(require) {')
+  return [
+    '/**',
+    ' * dsh-scheduled-message — browser bundle. GENERATED FILE, do not edit.',
+    ' *',
+    ' * Built from client.src.js + lib/core.js + locale/en.json + locale/zh.json by',
+    ' * scripts/build-client.mjs. Rebuild with `node scripts/build-client.mjs`;',
+    ' * `node --test test/` fails when this file is stale.',
+    ' */',
+    'window.__ModuleLoader__.load({',
+    `  id: ${JSON.stringify(PACKAGE_NAME)},`,
+    '  factory: (require) => {',
+    coreBlock(),
+    '',
+    localeBlock(),
+    '',
+    plugin,
+    '',
+    '    return createClientPlugin(require)',
+    '  },',
+    '})',
+    '',
+  ].join('\n')
+}
+
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const target = join(ROOT, 'client.js')
+  writeFileSync(target, buildClient(), 'utf8')
+  process.stdout.write(`wrote ${target}\n`)
+}

package/scripts/check.mjs

@@ -0,0 +1,101 @@
+/**
+ * Build the browser bundle and verify the package is internally consistent.
+ *
+ * Static gates only: nothing here imports the Host half, so a missing DSH
+ * installation cannot make the check fail for the wrong reason.
+ * @module dsh-scheduled-message/scripts/check
+ */
+
+import { execFileSync } from 'node:child_process'
+import { readFileSync, readdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { buildClient } from './build-client.mjs'
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
+const failures = []
+
+/**
+ * Assert one condition, collecting a readable failure instead of throwing.
+ * @param condition - the condition to require.
+ * @param message - diagnostic for a failure.
+ */
+function requireThat(condition, message) {
+  if (!condition) failures.push(message)
+}
+
+// 1. The committed bundle must equal a fresh build.
+const expected = buildClient()
+const actual = readFileSync(join(ROOT, 'client.js'), 'utf8')
+requireThat(actual === expected, 'client.js is stale: run `node scripts/build-client.mjs`')
+
+// 2. Both halves and the tests must parse.
+for (const file of ['index.js', 'lib/core.js', 'client.js', 'client.src.js']) {
+  try {
+    execFileSync(process.execPath, ['--check', join(ROOT, file)], { stdio: 'pipe' })
+  } catch (error) {
+    failures.push(`${file} does not parse: ${String(error.stderr ?? error.message).split('\n')[0]}`)
+  }
+}
+
+// 3. package.json and both dictionaries must parse and agree on their keys.
+const manifest = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'))
+requireThat(manifest.type === 'module', 'package.json must declare "type": "module"')
+requireThat(manifest.main === './index.js', 'package.json main must be ./index.js')
+requireThat(manifest.exports?.['./client'] === './client.js', 'package.json must export ./client -> ./client.js')
+requireThat(manifest.dsh?.client?.platform === 'web', 'package.json must declare dsh.client.platform = web')
+requireThat(manifest.dsh?.bundle?.patch === './cordis.patch.yml', 'package.json must point dsh.bundle.patch at cordis.patch.yml')
+
+const en = JSON.parse(readFileSync(join(ROOT, 'locale/en.json'), 'utf8'))
+const zh = JSON.parse(readFileSync(join(ROOT, 'locale/zh.json'), 'utf8'))
+requireThat(Object.keys(en).length > 0, 'locale/en.json is empty')
+requireThat(
+  JSON.stringify(Object.keys(en).sort()) === JSON.stringify(Object.keys(zh).sort()),
+  'locale/en.json and locale/zh.json must declare the same keys',
+)
+
+// 4. Every key the bundle asks for must exist in the dictionary. Keys composed
+// at runtime (repeat.<freq>, repeat.detail.<freq>, weekday.<day>, error.<code>,
+// attachments.<form>) are covered by the parity check below and by the smoke
+// test's rendering paths, so only literal keys are counted here.
+const usedKeys = new Set()
+const build = readFileSync(join(ROOT, 'client.src.js'), 'utf8')
+for (const match of build.matchAll(/\bt\(\s*'([^']+)'/g)) usedKeys.add(match[1])
+for (const match of build.matchAll(/label:\s*'([a-z][A-Za-z0-9.]*)'/g)) usedKeys.add(match[1])
+for (const key of usedKeys) {
+  requireThat(key in en, `client.src.js uses t('${key}') but locale/en.json does not define it`)
+  requireThat(key in zh, `client.src.js uses t('${key}') but locale/zh.json does not define it`)
+}
+
+// 5. Files the manifest promises must exist.
+for (const file of ['index.js', 'client.js', 'lib/core.js', 'icon.svg', 'cordis.patch.yml', 'README.md', 'docs/DETAIL.md']) {
+  try {
+    readFileSync(join(ROOT, file))
+  } catch {
+    failures.push(`missing file: ${file}`)
+  }
+}
+
+// 6. The bundle must not require anything outside the platform table.
+for (const match of expected.matchAll(/require\(\s*'([^']+)'\s*\)/g)) {
+  requireThat(
+    ['react', 'react-dom', 'react-dom/client', 'react/jsx-runtime'].includes(match[1]),
+    `client.js requires '${match[1]}', which is not in the browser platform table`,
+  )
+}
+
+// 7. The package must ship no TypeScript-only imports in the shipped halves.
+for (const file of readdirSync(join(ROOT, 'lib')).filter(name => name.endsWith('.js'))) {
+  const source = readFileSync(join(ROOT, 'lib', file), 'utf8')
+  requireThat(!/^import\s/m.test(source), `lib/${file} must stay dependency-free`)
+}
+
+if (failures.length > 0) {
+  process.stderr.write(`check failed:\n${failures.map(line => `  - ${line}`).join('\n')}\n`)
+  process.exitCode = 1
+} else {
+  process.stdout.write(
+    `check passed: ${usedKeys.size} literal locale keys of ${Object.keys(en).length} defined, `
+    + `${expected.length} bundle bytes\n`,
+  )
+}