nippotion 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Kenichi Takahashi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,185 @@
+# nippotion
+
+A CLI tool that delivers daily reports (diary entries) written in a Notion database to Slack channels based on their labels, every morning. Runs with **`npx nippotion` and a single config file**.
+
+- Delivers **the previous business day's** entries on weekday mornings (weekends are skipped; set `"holidays": "jp"` to also skip Japanese holidays via [@holiday-jp/holiday_jp](https://github.com/holiday-jp/holiday_jp). Monday delivers Friday's entries)
+- Routes entries to multiple Slack channels based on their labels (multi-select)
+- Randomly picks one entry each time to feature as the "pickup" entry
+- Timezone, holiday skipping, language (Japanese/English), and Slack message wording are all configurable (works for non-Japan offices and English-speaking workspaces too)
+
+```bash
+npx nippotion --config nippotion.json
+```
+
+Run it on a schedule with GitHub Actions, cron, or any Node-capable CI (a GitHub Actions example is below).
+
+## Requirements
+
+### Notion database
+
+The database you write daily reports into needs these four properties (names are configurable):
+
+| Property | Type | Purpose |
+|---|---|---|
+| One-liner | Title | The entry's title. Posted to Slack as a link |
+| Date | Date | Used to determine which entries to deliver |
+| Team | Multi-select | Used to route entries to the right channel |
+| Author | Created by | Used to display the writer's name |
+
+> [!NOTE]
+> The date property should hold **a date only, with no time component**. If a time is present, it may not match Notion's date filter and the entry could be skipped.
+
+### Notion integration
+
+1. Create an integration at [My integrations](https://www.notion.so/my-integrations) and note its API token
+2. Under the integration's capabilities, **enable "Read user information"** (no email address needed). Without it, the writer's name can't be retrieved and shows as "(unknown)"
+3. Share (connect) the target database with the integration
+4. Note the database's **data source ID**
+
+### Slack app
+
+1. Create an app at [Slack API](https://api.slack.com/apps), add the `chat:write` Bot Token Scope, and install it to your workspace
+2. Note the Bot User OAuth Token (starts with `xoxb-`)
+3. **Invite the bot user to every channel you deliver to** (it can't post to channels it hasn't been invited to)
+
+## Usage
+
+### CLI
+
+```bash
+# Debug run (logs the message content instead of posting to Slack)
+NOTION_API_TOKEN=xxx npx nippotion --debug
+
+# Production run
+NOTION_API_TOKEN=xxx SLACK_BOT_API_TOKEN=xoxb-xxx npx nippotion
+```
+
+| Option | Description |
+|---|---|
+| `-c, --config <path>` | Path to the config file (default: `nippotion.json` in the current directory) |
+| `-d, --debug` | Log the message content instead of posting to Slack |
+| `-h, --help` | Show help |
+
+| Environment variable | Description |
+|---|---|
+| `NOTION_API_TOKEN` | Notion integration API token (required) |
+| `SLACK_BOT_API_TOKEN` | Slack Bot User OAuth Token (not needed with `--debug`) |
+| `NIPPOTION_CONFIG` | Path to the config file (same as `--config`; the flag takes precedence) |
+| `NIPPOTION_DEBUG` | Set to `1` for debug mode (same as `--debug`) |
+| `NIPPOTION_LANG` | Language for CLI help and error messages (`ja` / `en`, default: `en`). The config's `language` takes precedence if set |
+| `TZ` | Fallback timezone for date evaluation. Prefer setting `timezone` in the config file |
+
+### Scheduled runs with GitHub Actions
+
+Place `nippotion.json` and the following workflow ([examples/notify.yml](./examples/notify.yml)) in your repository, and register `NOTION_API_TOKEN` / `SLACK_BOT_API_TOKEN` as secrets:
+
+```yaml
+name: nippotion
+on:
+  schedule:
+    - cron: '30 0 * * *'  # 9:30 JST
+  workflow_dispatch:
+    inputs:
+      debug_mode:
+        description: 'Debug mode (does not post to Slack)'
+        type: boolean
+        default: false
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+      - run: npx nippotion@1 ${{ github.event.inputs.debug_mode == 'true' && '--debug' || '' }}
+        env:
+          NOTION_API_TOKEN: ${{ secrets.NOTION_API_TOKEN }}
+          SLACK_BOT_API_TOKEN: ${{ secrets.SLACK_BOT_API_TOKEN }}
+```
+
+To verify it works, trigger it manually from the Actions tab with `debug_mode: true`.
+
+## Config reference (nippotion.json)
+
+```json
+{
+  "dataSourceId": "The Notion database's data source ID",
+  "timezone": "America/New_York",
+  "language": "en",
+  "holidays": "jp",
+  "properties": {
+    "title": "Name of the title property",
+    "labels": "Name of the multi-select property",
+    "author": "Name of the created-by property",
+    "date": "Name of the date property"
+  },
+  "footerText": "Text appended to the end of the message (Slack mrkdwn, optional)",
+  "messages": {
+    "header": "Here are the entries from {database} for the previous business day",
+    "pickup": "*:star: Today's pick goes to {writer}! :star:*",
+    "unknownWriter": "(unknown)",
+    "notificationText": "Daily reports have arrived"
+  },
+  "recipients": [
+    {
+      "labels": ["Entries with any of these labels"],
+      "channelId": "are delivered to this channel ID"
+    }
+  ]
+}
+```
+
+- `channelId` can be found at the end of the Slack channel's link URL, or from the channel details
+- Listing the same label in multiple recipients delivers it to multiple channels
+- `timezone` is the IANA timezone name used to evaluate business days and "the previous business day" (defaults to the runtime's local timezone if omitted)
+- `language` sets the default Slack message wording and the log/error message language (`ja` / `en`, **defaults to `en`**). Set `"language": "ja"` to use it in Japanese
+- Setting `holidays` to a country code also excludes that country's holidays from business days (**weekends only if omitted**; currently only `jp` — Japanese holidays — is supported). Non-business days are not delivered, and are also skipped when computing "the previous business day" (entries from a holiday arrive together on the next business day)
+- `messages` lets you override individual pieces of Slack wording. All fields are optional (defaults follow `language`). `{database}` is replaced with a link to the database, and `{writer}` with the entry's author name
+
+### Example: Japanese setup
+
+For a Japanese-language Notion database and Slack workspace, set `language` to `"ja"` and use Japanese property names:
+
+```json
+{
+  "dataSourceId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  "timezone": "Asia/Tokyo",
+  "language": "ja",
+  "holidays": "jp",
+  "properties": {
+    "title": "今日のひとこと",
+    "labels": "所属",
+    "author": "書いた人",
+    "date": "日付"
+  },
+  "footerText": "powered by <https://github.com/kenchan/nippotion|nippotion>",
+  "recipients": [
+    {
+      "labels": ["チームA"],
+      "channelId": "C0123456789"
+    },
+    {
+      "labels": ["チームB", "チームC"],
+      "channelId": "C9876543210"
+    }
+  ]
+}
+```
+
+With `"language": "ja"`, the default `messages` wording is Japanese too, so it can be omitted here.
+
+## Development
+
+```bash
+npm ci
+npm start -- --debug   # run from source with tsx
+npm run typecheck      # type check
+npm run lint           # ESLint
+npm test               # tests
+npm run build          # build dist/ with tsup
+```
+
+## License
+
+[MIT](./LICENSE)

package/dist/cli.js

@@ -0,0 +1,588 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "util";
+
+// src/i18n.ts
+import i18next from "i18next";
+
+// src/locales/ja.ts
+var ja = {
+  cli: {
+    help: `\u4F7F\u3044\u65B9: nippotion [options]
+
+Notion\u306E\u65E5\u5831\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u304B\u3089\u524D\u55B6\u696D\u65E5\u5206\u3092\u53D6\u5F97\u3057\u3001
+\u30E9\u30D9\u30EB\u306B\u5FDC\u3058\u305FSlack\u30C1\u30E3\u30F3\u30CD\u30EB\u3078\u914D\u4FE1\u3057\u307E\u3059\u3002
+
+\u30AA\u30D7\u30B7\u30E7\u30F3:
+  -c, --config <path>  \u8A2D\u5B9A\u30D5\u30A1\u30A4\u30EB\u306E\u30D1\u30B9\uFF08\u30C7\u30D5\u30A9\u30EB\u30C8: ./nippotion.json\uFF09
+  -d, --debug          Slack\u306B\u6295\u7A3F\u305B\u305A\u3001\u6295\u7A3F\u5185\u5BB9\u3092\u30ED\u30B0\u306B\u51FA\u529B\u3059\u308B
+  -h, --help           \u3053\u306E\u30D8\u30EB\u30D7\u3092\u8868\u793A\u3059\u308B
+
+\u74B0\u5883\u5909\u6570:
+  NOTION_API_TOKEN     Notion Integration\u306EAPI\u30C8\u30FC\u30AF\u30F3\uFF08\u5FC5\u9808\uFF09
+  SLACK_BOT_API_TOKEN  Slack\u306EBot User OAuth Token\uFF08--debug\u6642\u306F\u4E0D\u8981\uFF09
+`
+  },
+  config: {
+    notObject: "\u8A2D\u5B9A\u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+    mustBeString: '\u8A2D\u5B9A\u306E "{{keyPath}}" \u306F\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08\u5B9F\u969B\u306E\u578B: {{type}}\uFF09',
+    mustBeStringArray: '\u8A2D\u5B9A\u306E "{{keyPath}}" \u306F\u6587\u5B57\u5217\u306E\u914D\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',
+    mustBeObject: '\u8A2D\u5B9A\u306E "{{keyPath}}" \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',
+    mustBeArray: '\u8A2D\u5B9A\u306E "{{keyPath}}" \u306F\u914D\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',
+    invalidTimezone: '\u8A2D\u5B9A\u306E "{{keyPath}}" \u304C\u4E0D\u6B63\u3067\u3059: "{{timezone}}" \u306F\u6709\u52B9\u306AIANA\u30BF\u30A4\u30E0\u30BE\u30FC\u30F3\u540D\u3067\u306F\u3042\u308A\u307E\u305B\u3093\uFF08\u4F8B: Asia/Tokyo\uFF09',
+    invalidLanguage: '\u8A2D\u5B9A\u306E "{{keyPath}}" \u306F "ja" \u307E\u305F\u306F "en" \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',
+    invalidHolidays: '\u8A2D\u5B9A\u306E "{{keyPath}}" \u304C\u4E0D\u6B63\u3067\u3059: \u5BFE\u5FDC\u3057\u3066\u3044\u308B\u5024\u306F {{supported}} \u3067\u3059',
+    readFailed: '\u8A2D\u5B9A\u30D5\u30A1\u30A4\u30EB "{{filePath}}" \u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3067\u3057\u305F: {{message}}',
+    parseFailed: '\u8A2D\u5B9A\u30D5\u30A1\u30A4\u30EB "{{filePath}}" \u306EJSON\u30D1\u30FC\u30B9\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {{message}}'
+  },
+  env: {
+    missing: "\u5FC5\u9808\u74B0\u5883\u5909\u6570\u304C\u8A2D\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093: {{vars}}"
+  },
+  notion: {
+    propertyNotFound: '\u30D7\u30ED\u30D1\u30C6\u30A3 "{{name}}" \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093'
+  },
+  slack: {
+    header: "\u524D\u55B6\u696D\u65E5\u306E{database}\u306F\u3053\u3061\u3089",
+    pickup: "*:star:\u4ECA\u65E5\u306E\u30D4\u30C3\u30AF\u30A2\u30C3\u30D7\u65E5\u8A18\u306F {writer} \u3055\u3093:star:*",
+    unknownWriter: "\uFF08\u4E0D\u660E\uFF09",
+    notificationText: "\u524D\u55B6\u696D\u65E5\u306E\u65E5\u5831\u304C\u5C4A\u304D\u307E\u3057\u305F"
+  }
+};
+
+// src/locales/en.ts
+var en = {
+  cli: {
+    help: `Usage: nippotion [options]
+
+Fetches entries for the previous business day from a Notion database
+and delivers them to Slack channels based on their labels.
+
+Options:
+  -c, --config <path>  Path to the config file (default: ./nippotion.json)
+  -d, --debug          Log the messages instead of posting to Slack
+  -h, --help           Show this help
+
+Environment variables:
+  NOTION_API_TOKEN     Notion Integration API token (required)
+  SLACK_BOT_API_TOKEN  Slack Bot User OAuth Token (not needed with --debug)
+`
+  },
+  config: {
+    notObject: "Config must be an object",
+    mustBeString: 'Config "{{keyPath}}" must be a string (got: {{type}})',
+    mustBeStringArray: 'Config "{{keyPath}}" must be an array of strings',
+    mustBeObject: 'Config "{{keyPath}}" must be an object',
+    mustBeArray: 'Config "{{keyPath}}" must be an array',
+    invalidTimezone: 'Config "{{keyPath}}" is invalid: "{{timezone}}" is not a valid IANA timezone name (e.g. Asia/Tokyo)',
+    invalidLanguage: 'Config "{{keyPath}}" must be "ja" or "en"',
+    invalidHolidays: 'Config "{{keyPath}}" is invalid: supported values are {{supported}}',
+    readFailed: 'Failed to read config file "{{filePath}}": {{message}}',
+    parseFailed: 'Failed to parse config file "{{filePath}}" as JSON: {{message}}'
+  },
+  env: {
+    missing: "Required environment variables are not set: {{vars}}"
+  },
+  notion: {
+    propertyNotFound: 'Property "{{name}}" was not found in the data source'
+  },
+  slack: {
+    header: "Here are the entries from {database} for the previous business day",
+    pickup: "*:star: Today's pick goes to {writer}! :star:*",
+    unknownWriter: "(unknown)",
+    notificationText: "Daily reports have arrived"
+  }
+};
+
+// src/i18n.ts
+void i18next.init({
+  lng: process.env.NIPPOTION_LANG ?? "en",
+  fallbackLng: "en",
+  initAsync: false,
+  resources: {
+    ja: { translation: ja },
+    en: { translation: en }
+  },
+  interpolation: {
+    // Not embedded in HTML, so HTML-escaping of & and quotes is unnecessary
+    escapeValue: false
+  }
+});
+var t = i18next.t.bind(i18next);
+var i18n_default = i18next;
+
+// src/main.ts
+import { Client as Client2 } from "@notionhq/client";
+import { WebClient } from "@slack/web-api";
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+import timezone from "dayjs/plugin/timezone.js";
+
+// src/config.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+// src/workday.ts
+import holidayJp from "@holiday-jp/holiday_jp";
+var HOLIDAY_COUNTRIES = ["jp"];
+var isHoliday = (date, country) => {
+  switch (country) {
+    case "jp":
+      return holidayJp.isHoliday(new Date(date.year(), date.month(), date.date()));
+  }
+};
+var isWeekendOrHoliday = (date, holidays) => {
+  if (date.day() === 0 || date.day() === 6) return true;
+  return holidays !== void 0 && isHoliday(date, holidays);
+};
+var getPreviousWorkday = (date, holidays) => {
+  let previousWorkday = date.subtract(1, "day");
+  while (isWeekendOrHoliday(previousWorkday, holidays)) {
+    previousWorkday = previousWorkday.subtract(1, "day");
+  }
+  return previousWorkday;
+};
+
+// src/config.ts
+var LANGUAGES = ["ja", "en"];
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var requireString = (value, keyPath) => {
+  if (typeof value !== "string") {
+    throw new Error(t("config.mustBeString", { keyPath, type: typeof value }));
+  }
+  return value;
+};
+var requireStringArray = (value, keyPath) => {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(t("config.mustBeStringArray", { keyPath }));
+  }
+  return value;
+};
+var validateProperties = (value, keyPath) => {
+  if (!isPlainObject(value)) {
+    throw new Error(t("config.mustBeObject", { keyPath }));
+  }
+  return {
+    title: requireString(value.title, `${keyPath}.title`),
+    labels: requireString(value.labels, `${keyPath}.labels`),
+    author: requireString(value.author, `${keyPath}.author`),
+    date: requireString(value.date, `${keyPath}.date`)
+  };
+};
+var validateRecipient = (value, keyPath) => {
+  if (!isPlainObject(value)) {
+    throw new Error(t("config.mustBeObject", { keyPath }));
+  }
+  return {
+    labels: requireStringArray(value.labels, `${keyPath}.labels`),
+    channelId: requireString(value.channelId, `${keyPath}.channelId`)
+  };
+};
+var validateRecipients = (value, keyPath) => {
+  if (!Array.isArray(value)) {
+    throw new Error(t("config.mustBeArray", { keyPath }));
+  }
+  return value.map((item, index) => validateRecipient(item, `${keyPath}[${index}]`));
+};
+var validateHolidays = (value, keyPath) => {
+  const country = requireString(value, keyPath);
+  if (!HOLIDAY_COUNTRIES.includes(country)) {
+    throw new Error(t("config.invalidHolidays", { keyPath, supported: HOLIDAY_COUNTRIES.join(", ") }));
+  }
+  return country;
+};
+var validateLanguage = (value, keyPath) => {
+  const language = requireString(value, keyPath);
+  if (!LANGUAGES.includes(language)) {
+    throw new Error(t("config.invalidLanguage", { keyPath }));
+  }
+  return language;
+};
+var validateMessages = (value, keyPath, language) => {
+  const fixedT = i18n_default.getFixedT(language ?? i18n_default.language);
+  const messages = {
+    header: fixedT("slack.header"),
+    pickup: fixedT("slack.pickup"),
+    unknownWriter: fixedT("slack.unknownWriter"),
+    notificationText: fixedT("slack.notificationText")
+  };
+  if (value === void 0) return messages;
+  if (!isPlainObject(value)) {
+    throw new Error(t("config.mustBeObject", { keyPath }));
+  }
+  for (const key of Object.keys(messages)) {
+    if (value[key] !== void 0) {
+      messages[key] = requireString(value[key], `${keyPath}.${key}`);
+    }
+  }
+  return messages;
+};
+var validateTimezone = (value, keyPath) => {
+  const tz = requireString(value, keyPath);
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+  } catch {
+    throw new Error(t("config.invalidTimezone", { keyPath, timezone: tz }));
+  }
+  return tz;
+};
+var validateConfig = (data) => {
+  if (!isPlainObject(data)) {
+    throw new Error(t("config.notObject"));
+  }
+  const language = data.language === void 0 ? void 0 : validateLanguage(data.language, "language");
+  const config = {
+    dataSourceId: requireString(data.dataSourceId, "dataSourceId"),
+    properties: validateProperties(data.properties, "properties"),
+    recipients: validateRecipients(data.recipients, "recipients"),
+    messages: validateMessages(data.messages, "messages", language)
+  };
+  if (language !== void 0) {
+    config.language = language;
+  }
+  if (data.holidays !== void 0) {
+    config.holidays = validateHolidays(data.holidays, "holidays");
+  }
+  if (data.footerText !== void 0) {
+    config.footerText = requireString(data.footerText, "footerText");
+  }
+  if (data.timezone !== void 0) {
+    config.timezone = validateTimezone(data.timezone, "timezone");
+  }
+  return config;
+};
+var loadConfig = (filePath) => {
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(t("config.readFailed", { filePath, message }));
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(t("config.parseFailed", { filePath, message }));
+  }
+  return validateConfig(data);
+};
+var resolveConfigPath = () => resolve(process.cwd(), process.env.NIPPOTION_CONFIG ?? "nippotion.json");
+
+// src/notion.ts
+import { isFullPage, collectPaginatedAPI } from "@notionhq/client";
+
+// src/retry.ts
+import pRetry from "p-retry";
+var asRecord = (value) => typeof value === "object" && value !== null ? value : void 0;
+var extractErrorInfo = (error) => {
+  const err = asRecord(error);
+  const originalError = asRecord(err?.originalError);
+  const wrappedError = asRecord(err?.error);
+  const cause = asRecord(err?.cause);
+  return {
+    code: err?.code ?? originalError?.code ?? wrappedError?.code,
+    status: err?.status ?? originalError?.status ?? wrappedError?.status,
+    causeCode: cause?.code
+  };
+};
+var isKnownRetryableCode = (code) => typeof code === "string" && ["ECONNRESET", "ETIMEDOUT", "ENOTFOUND"].includes(code);
+var isRetryableError = (error) => {
+  const { code, status, causeCode } = extractErrorInfo(error);
+  return code === "notionhq_client_request_timeout" || // Notion rate limiting (429 / rate_limited) resolves by waiting, so retry it
+  code === "rate_limited" || status === 429 || code === "notionhq_client_response_error" && (status === void 0 || typeof status === "number" && status >= 500) || isKnownRetryableCode(code) || isKnownRetryableCode(causeCode);
+};
+var formatError = (error) => {
+  const message = asRecord(error)?.message;
+  if (typeof message === "string" && message) return message;
+  if (typeof error === "string") return error;
+  return JSON.stringify(error, null, 2);
+};
+var withRetry = (fn) => pRetry(fn, {
+  retries: 3,
+  minTimeout: 5e3,
+  // Aborting via shouldRetry instead of throwing AbortError lets the original error
+  // propagate with its structure and stack intact (nothing is lost to stringification)
+  shouldRetry: ({ error }) => isRetryableError(error),
+  onFailedAttempt: ({ error, attemptNumber, retriesLeft, retryDelay }) => {
+    const { code, status } = extractErrorInfo(error);
+    const retryable = isRetryableError(error);
+    console.log(`Notion API call failed (attempt ${attemptNumber}/${retriesLeft + attemptNumber}):`, {
+      code,
+      status,
+      message: error.message,
+      isRetryable: retryable
+    });
+    if (!retryable) {
+      console.error("Non-retryable error encountered:", formatError(error));
+    } else if (retriesLeft > 0) {
+      console.log(`Retrying in ${retryDelay / 1e3}s...`);
+    }
+  }
+});
+
+// src/notion.ts
+var getDateFilter = (previousWorkday, today, dateProperty) => {
+  const previousDay = today.subtract(1, "day");
+  if (previousWorkday.isSame(previousDay, "day")) {
+    return {
+      "property": dateProperty,
+      "date": { "equals": previousWorkday.format("YYYY-MM-DD") }
+    };
+  }
+  return {
+    "and": [{
+      "property": dateProperty,
+      "date": {
+        "on_or_after": previousWorkday.format("YYYY-MM-DD")
+      }
+    }, {
+      "property": dateProperty,
+      "date": {
+        "on_or_before": previousDay.format("YYYY-MM-DD")
+      }
+    }]
+  };
+};
+var getDatabaseInfo = async (client, dataSourceId, requiredProperties) => withRetry(async () => {
+  const dataSource = await client.dataSources.retrieve({
+    data_source_id: dataSourceId
+  });
+  const propertyIds = requiredProperties.map((name) => {
+    const prop = Object.values(dataSource.properties).find((p) => p.name === name);
+    if (!prop) throw new Error(t("notion.propertyNotFound", { name }));
+    return prop.id;
+  });
+  return {
+    url: dataSource.url,
+    title: dataSource.title.map((t2) => t2.plain_text).join(""),
+    propertyIds
+  };
+});
+var getAllPages = async (client, dataSourceId, filter, filterProperties) => {
+  const results = await collectPaginatedAPI(
+    (args) => withRetry(() => client.dataSources.query(args)),
+    {
+      data_source_id: dataSourceId,
+      filter,
+      filter_properties: filterProperties
+    }
+  );
+  return results.filter(isFullPage);
+};
+var getTitle = (page, titleProperty) => {
+  const prop = page.properties[titleProperty];
+  if (prop?.type !== "title") return "";
+  return prop.title.map((t2) => t2.plain_text).join("");
+};
+var getWriterName = (page, authorProperty) => {
+  const prop = page.properties[authorProperty];
+  if (prop?.type !== "created_by") return null;
+  const user = prop.created_by;
+  return "name" in user ? user.name : null;
+};
+var getLabels = (page, labelsProperty) => {
+  const prop = page.properties[labelsProperty];
+  if (prop?.type !== "multi_select") return [];
+  return prop.multi_select.map((s) => s.name);
+};
+var toEntry = (page, properties) => {
+  const title = getTitle(page, properties.title);
+  if (!title) return null;
+  return {
+    title,
+    writerName: getWriterName(page, properties.author),
+    labels: getLabels(page, properties.labels),
+    url: page.url
+  };
+};
+
+// src/slack.ts
+var escapeMrkdwn = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var fillTemplate = (template, vars) => template.replace(/\{(\w+)\}/g, (match, key) => vars[key] ?? match);
+var createHeaderBlock = (databaseUrl, databaseTitle, headerTemplate) => [
+  {
+    type: "section",
+    text: {
+      type: "mrkdwn",
+      text: fillTemplate(headerTemplate, { database: `<${databaseUrl}|${escapeMrkdwn(databaseTitle)}>` })
+    }
+  },
+  {
+    type: "divider"
+  }
+];
+var createFooterBlock = (footerText) => footerText ? [
+  {
+    type: "divider"
+  },
+  {
+    type: "context",
+    elements: [
+      {
+        type: "mrkdwn",
+        text: footerText
+      }
+    ]
+  }
+] : [];
+var toEntryBlock = (entry, messages, pickup = false) => {
+  const title = escapeMrkdwn(entry.title);
+  const writerName = escapeMrkdwn(entry.writerName ?? messages.unknownWriter);
+  if (pickup) {
+    return {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `${fillTemplate(messages.pickup, { writer: writerName })}
+<${entry.url}|${title}>`
+      }
+    };
+  }
+  return {
+    type: "section",
+    text: {
+      type: "mrkdwn",
+      text: `*${writerName}*
+<${entry.url}|${title}>`
+    }
+  };
+};
+var MAX_BLOCKS_PER_MESSAGE = 50;
+var buildMessageBlocks = (headerBlock, entriesBlock, pickupBlock, footerBlock) => {
+  const singleMessageBlocks = [...headerBlock, ...entriesBlock, ...pickupBlock, ...footerBlock];
+  if (singleMessageBlocks.length <= MAX_BLOCKS_PER_MESSAGE) {
+    return [singleMessageBlocks];
+  }
+  const messages = [];
+  const maxEntriesInFirstMessage = MAX_BLOCKS_PER_MESSAGE - headerBlock.length;
+  const maxEntriesInLastMessage = MAX_BLOCKS_PER_MESSAGE - pickupBlock.length - footerBlock.length;
+  messages.push([...headerBlock, ...entriesBlock.slice(0, maxEntriesInFirstMessage)]);
+  let rest = entriesBlock.slice(maxEntriesInFirstMessage);
+  while (rest.length > maxEntriesInLastMessage) {
+    messages.push(rest.slice(0, MAX_BLOCKS_PER_MESSAGE));
+    rest = rest.slice(MAX_BLOCKS_PER_MESSAGE);
+  }
+  messages.push([...rest, ...pickupBlock, ...footerBlock]);
+  return messages;
+};
+var notifyNippo = async (ctx, recipient) => {
+  const filteredEntries = ctx.entries.filter(
+    (entry) => recipient.labels.some((label) => entry.labels.includes(label))
+  );
+  const entriesBlock = filteredEntries.map((entry) => toEntryBlock(entry, ctx.messages));
+  const pickupBlock = ctx.pickup ? [toEntryBlock(ctx.pickup, ctx.messages, true)] : [];
+  const messages = buildMessageBlocks(ctx.headerBlock, entriesBlock, pickupBlock, ctx.footerBlock);
+  if (ctx.debug) {
+    console.log("send to #" + recipient.channelId);
+    console.log(JSON.stringify(messages, null, 2));
+    return true;
+  }
+  let succeeded = true;
+  for (const blocks of messages) {
+    try {
+      await ctx.slack.chat.postMessage({
+        text: ctx.messages.notificationText,
+        blocks,
+        channel: recipient.channelId
+      });
+    } catch (error) {
+      console.error(`Failed to send notification to channel: ${recipient.channelId}`, error);
+      succeeded = false;
+    }
+  }
+  return succeeded;
+};
+
+// src/main.ts
+dayjs.extend(utc);
+dayjs.extend(timezone);
+var checkRequiredEnvVars = (debug) => {
+  const missing = [];
+  if (!process.env.NOTION_API_TOKEN) missing.push("NOTION_API_TOKEN");
+  if (!debug && !process.env.SLACK_BOT_API_TOKEN) missing.push("SLACK_BOT_API_TOKEN");
+  if (missing.length > 0) {
+    console.error(t("env.missing", { vars: missing.join(", ") }));
+    process.exit(1);
+  }
+};
+var main = async () => {
+  const debug = process.env.NIPPOTION_DEBUG === "1";
+  checkRequiredEnvVars(debug);
+  let config;
+  try {
+    config = loadConfig(resolveConfigPath());
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  if (config.language) await i18n_default.changeLanguage(config.language);
+  const today = config.timezone ? dayjs().tz(config.timezone) : dayjs();
+  if (isWeekendOrHoliday(today, config.holidays)) return;
+  const client = new Client2({
+    auth: process.env.NOTION_API_TOKEN,
+    timeoutMs: 12e4
+    // extended from the 60s default
+  });
+  const slack = new WebClient(process.env.SLACK_BOT_API_TOKEN);
+  const requiredProperties = [config.properties.labels, config.properties.title, config.properties.author];
+  const { url, title, propertyIds } = await getDatabaseInfo(client, config.dataSourceId, requiredProperties);
+  const previousWorkday = getPreviousWorkday(today, config.holidays);
+  const filter = getDateFilter(previousWorkday, today, config.properties.date);
+  console.log("nippotion start:", JSON.stringify({
+    now: today.toISOString(),
+    timezone: config.timezone ?? null,
+    today: today.format("YYYY-MM-DD"),
+    previousWorkday: previousWorkday.format("YYYY-MM-DD"),
+    query: {
+      data_source_id: config.dataSourceId,
+      filter
+    }
+  }, null, 2));
+  const pages = await getAllPages(client, config.dataSourceId, filter, propertyIds);
+  const entries = pages.map((page) => toEntry(page, config.properties)).filter((entry) => entry !== null);
+  console.log("entries:", JSON.stringify({ pages: pages.length, entries: entries.length }));
+  if (entries.length === 0) return;
+  const pickup = entries[Math.floor(Math.random() * entries.length)] ?? null;
+  const ctx = {
+    slack,
+    entries,
+    pickup,
+    headerBlock: createHeaderBlock(url, title, config.messages.header),
+    footerBlock: createFooterBlock(config.footerText),
+    messages: config.messages,
+    debug
+  };
+  let hasFailure = false;
+  for (const recipient of config.recipients) {
+    const succeeded = await notifyNippo(ctx, recipient);
+    if (!succeeded) hasFailure = true;
+  }
+  if (hasFailure) {
+    process.exitCode = 1;
+  }
+};
+
+// src/cli.ts
+var values;
+try {
+  ({ values } = parseArgs({
+    options: {
+      config: { type: "string", short: "c" },
+      debug: { type: "boolean", short: "d", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  }));
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  console.error(t("cli.help"));
+  process.exit(1);
+}
+if (values.help) {
+  console.log(t("cli.help"));
+  process.exit(0);
+}
+if (values.config) process.env.NIPPOTION_CONFIG = values.config;
+if (values.debug) process.env.NIPPOTION_DEBUG = "1";
+await main();

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "nippotion",
+  "version": "0.0.1",
+  "description": "Deliver daily reports written in Notion to Slack channels based on their labels",
+  "type": "module",
+  "scripts": {
+    "start": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build": "tsup",
+    "prepublishOnly": "npm run build"
+  },
+  "author": "Kenichi Takahashi",
+  "license": "MIT",
+  "dependencies": {
+    "@holiday-jp/holiday_jp": "^2.5.1",
+    "@notionhq/client": "^5.22.0",
+    "@slack/web-api": "^7.17.0",
+    "dayjs": "^1.11.21",
+    "i18next": "^26.3.6",
+    "p-retry": "^8.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.39.5",
+    "@types/node": "^24.13.3",
+    "eslint": "9.39.5",
+    "tsup": "8.5.1",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "8.65.0",
+    "vitest": "^4.1.9"
+  },
+  "overrides": {
+    "brace-expansion@1": "^5.0.8",
+    "esbuild": "^0.28.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kenchan/nippotion.git"
+  },
+  "bin": {
+    "nippotion": "dist/cli.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ]
+}