pczzz 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pcoff contributors
+
+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,91 @@
+# pcoff
+
+定时关机命令行工具
+
+## 安装
+
+```bash
+npm install -g pcoff
+```
+
+## 使用
+
+### 命令行直接指定时间
+
+```bash
+pcoff 1s      # 1 秒后关机
+pcoff 20m     # 20 分钟后关机
+pcoff 1h      # 1 小时后关机
+pcoff 1h30m   # 组合单位：1 小时 30 分钟后
+pcoff 90      # 纯数字按秒计
+pcoff 30秒    # 中文单位也可以
+```
+
+支持的单位：`s` 秒 / `m` 分钟 / `h` 小时 / `d` 天（以及 sec、min、hour、秒、分钟、小时等写法），可以自由组合（如 `1h30m`）。
+
+### 交互式菜单
+
+直接运行 `pcoff`（不带参数）：
+
+```
+你想多久关机？
+  1. 30 秒
+  2. 20 分钟
+  3. 30 分钟
+  4. 1 小时
+  5. 2 小时
+  6. 自定义
+  7. 取消当前关机
+  8. 退出
+```
+
+选择「自定义」后可继续输入任意时间（如 `45m`、`1h20m`、`300`）。
+
+### 取消关机
+
+```bash
+pcoff cancel
+```
+
+或在菜单中选择「取消当前关机」。
+
+已安排的关机由操作系统执行，退出程序、关闭窗口都不影响；只有显式取消才会生效。
+
+## 重复安排检测
+
+安排新的关机前，pcoff 会检查是否已存在定时关机任务：
+
+1. **自己的记录**（`~/.pcoff/task.json`）：能显示确切的剩余时间，例如
+   「当前已安排 1 小时 29 分钟 后关机（本工具于 23:01:35 设置）。要重新安排吗？(Y/N)」
+2. **系统级检测（仅 Windows）**：即使任务不是本工具设置的（比如手动执行过 `shutdown -s -t 3600`），也能检测到。Windows 在已有计划关机时再次执行 `shutdown` 会返回错误码 1190，据此弹出「要取消旧任务并重新安排吗？」的询问。外来任务拿不到剩余时间，只能提示存在。
+
+注意：电脑重启后 Windows 的关机计时器会消失。此时记录文件若还在，重新安排时系统探测会发现"其实没有旧任务"，直接按新时间安排，记录随之更新，不会误伤。
+
+## 平台差异
+
+| 平台          | 精度   | 权限                          | 说明                                                  |
+| ------------- | ------ | ----------------------------- | ----------------------------------------------------- |
+| Windows       | 秒级   | 无需管理员                    | 完整支持，含系统级检测                                |
+| macOS / Linux | 分钟级 | 需要 root（`sudo pcoff ...`） | `shutdown` 命令仅支持分钟；无系统级检测，依赖记录文件 |
+
+## 开发
+
+```bash
+npm install
+npm run build   # tsc 编译到 dist/
+npm test        # 冒烟测试（PCOFF_DRY_RUN=1，不会真的关机）
+npm link        # 本地全局试用 pcoff 命令
+```
+
+测试钩子：`PCOFF_DRY_RUN=1` 跳过真实的 shutdown 调用；`PCOFF_HOME` 指定记录文件目录（默认 `~/.pcoff`）。
+
+## 发布
+
+```bash
+npm login
+npm publish
+```
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { MAX_SECONDS, formatClock, formatDuration, formatTimeOfDay, parseDuration } from './time.js';
+import { clearTask, loadActiveTask, saveTask } from './store.js';
+import { abortShutdown, scheduleShutdown } from './shutdown.js';
+import { Prompt } from './menu.js';
+import { bold, cyan, dim, green, red, yellow } from './ui.js';
+const { version: VERSION } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const HELP = `pcoff — 定时关机小工具
+
+用法:
+  pcoff                打开交互式菜单
+  pcoff <时间>         指定时间后关机，例如: pcoff 30s
+  pcoff cancel         取消当前已安排的定时关机
+
+时间格式（可自由组合）:
+  30s     30 秒后          20m     20 分钟后       1h      1 小时后
+  1h30m   1 小时 30 分钟后  1d12h   也支持天        90      纯数字按秒计
+  中文单位同样有效: 30秒 / 20分钟 / 1小时30分
+
+选项:
+  -h, --help     显示本帮助
+  -v, --version  显示版本号
+
+说明:
+  · 关机计划由操作系统执行，退出本程序或关闭窗口不会取消它。
+  · 取消方式: pcoff cancel，或菜单中的「取消当前关机」。
+  · Windows 完整支持（秒级精度，无需管理员权限）。
+  · macOS / Linux: shutdown 需要 root 权限（sudo pcoff ...），且只能按分钟安排。`;
+function fail(message) {
+    console.error(message);
+    process.exit(1);
+}
+function exitGracefully() {
+    process.stdout.write('\n已退出。已设置的定时关机仍会执行；取消请运行 pcoff cancel。\n');
+    process.exit(0);
+}
+/** 安排成功后的提示 + 倒计时。倒计时期间 Ctrl+C 随时退出，不影响系统层面的关机。 */
+async function printScheduled(seconds) {
+    const fireAt = new Date(Date.now() + seconds * 1000);
+    try {
+        await saveTask(seconds);
+    }
+    catch (err) {
+        console.log(yellow(`（记录文件写入失败，不影响已安排的关机：${err instanceof Error ? err.message : String(err)}）`));
+    }
+    console.log(green(`✅ 已安排在本机 ${formatTimeOfDay(fireAt)} 自动关机（${formatDuration(seconds)} 后）。`));
+    console.log(dim('   关机由系统执行，关闭本窗口不影响；取消请运行 pcoff cancel。'));
+    startCountdown(seconds);
+}
+function startCountdown(seconds) {
+    if (!process.stdout.isTTY)
+        return;
+    const fireAt = Date.now() + seconds * 1000;
+    const timer = setInterval(() => {
+        const left = Math.ceil((fireAt - Date.now()) / 1000);
+        if (left <= 0) {
+            clearInterval(timer);
+            process.stdout.write('\r' + ' '.repeat(80) + '\r');
+            console.log(green('时间到，系统正在关机。'));
+            process.exit(0);
+        }
+        process.stdout.write(`\r${dim(`剩余 ${formatClock(left)}，Ctrl+C 退出（不影响关机）`)}`);
+    }, 1000);
+}
+/**
+ * 带检测的安排流程。返回 true 表示新计划已生效（此后由倒计时接管），
+ * 返回 false 表示用户选择保留旧计划。
+ *
+ * 检测分两层：
+ * 1. 记录文件（~/.pcoff/task.json）：本工具自己设置的、尚未到期的任务，能给出剩余时间；
+ * 2. Windows 系统探测：shutdown 若因错误码 1190 失败，说明系统里另有一个计划中的关机
+ *    （外来任务或重启后记录失效），此时询问用户是否取消旧的再排新的。
+ */
+async function scheduleWithCheck(prompt, seconds) {
+    const own = await loadActiveTask();
+    if (own) {
+        const remaining = Math.ceil((Date.parse(own.fireAt) - Date.now()) / 1000);
+        const replace = await prompt.confirm(`当前已安排 ${bold(formatDuration(remaining))} 后关机（本工具于 ${formatTimeOfDay(new Date(own.createdAt))} 设置）。要重新安排吗？`);
+        if (!replace) {
+            console.log(dim('已保留原计划；取消请运行 pcoff cancel。'));
+            return false;
+        }
+    }
+    let res = await scheduleShutdown(seconds);
+    if (res.ok) {
+        await printScheduled(seconds);
+        return true;
+    }
+    if (res.alreadyScheduled) {
+        if (!own) {
+            const replace = await prompt.confirm('检测到系统已有一个定时关机任务（可能由其他方式设置，剩余时间未知）。要取消它并按新时间安排吗？');
+            if (!replace) {
+                console.log(dim('已保留现有计划；取消请运行 pcoff cancel。'));
+                return false;
+            }
+        }
+        // 用户已确认替换（或旧任务就是本工具设的），先取消系统里的旧任务再排新的
+        await abortShutdown();
+        res = await scheduleShutdown(seconds);
+        if (res.ok) {
+            await printScheduled(seconds);
+            return true;
+        }
+    }
+    let message = red(`安排关机失败：${res.stderr || '未知错误'}`);
+    if (process.platform !== 'win32' && /root|permission|permitt|not allowed/i.test(res.stderr)) {
+        message += dim('\n（macOS/Linux 的 shutdown 需要 root 权限，可尝试：sudo pcoff ...）');
+    }
+    fail(message);
+}
+async function runCancel() {
+    const res = await abortShutdown();
+    await clearTask();
+    if (res.ok) {
+        console.log(green('✅ 已取消当前定时关机。'));
+    }
+    else {
+        console.log(yellow('没有需要取消的定时关机（可能不存在、电脑已重启或已执行）。'));
+        if (res.stderr)
+            console.log(dim(`  系统返回：${res.stderr}`));
+    }
+}
+async function menuLoop(prompt) {
+    for (;;) {
+        console.log(`\n${bold('你想多久关机？')}`);
+        ['30 秒', '20 分钟', '30 分钟', '1 小时', '2 小时', '自定义', '取消当前关机', '退出'].forEach((label, i) => console.log(`  ${cyan(String(i + 1))}. ${label}`));
+        const choice = await prompt.choose(`请选择 ${dim('[1-8]')}: `, 1, 8);
+        switch (choice) {
+            case 1:
+                if (await scheduleWithCheck(prompt, 30))
+                    return;
+                break;
+            case 2:
+                if (await scheduleWithCheck(prompt, 20 * 60))
+                    return;
+                break;
+            case 3:
+                if (await scheduleWithCheck(prompt, 30 * 60))
+                    return;
+                break;
+            case 4:
+                if (await scheduleWithCheck(prompt, 60 * 60))
+                    return;
+                break;
+            case 5:
+                if (await scheduleWithCheck(prompt, 2 * 60 * 60))
+                    return;
+                break;
+            case 6:
+                if (await scheduleWithCheck(prompt, await prompt.askDuration()))
+                    return;
+                break;
+            case 7:
+                await runCancel();
+                break;
+            case 8:
+                console.log(dim('再见 👋'));
+                return;
+        }
+    }
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.includes('-h') || argv.includes('--help')) {
+        console.log(HELP);
+        return;
+    }
+    if (argv.includes('-v') || argv.includes('--version')) {
+        console.log(`pcoff v${VERSION}`);
+        return;
+    }
+    if (argv.includes('cancel') || argv.includes('-c')) {
+        await runCancel();
+        return;
+    }
+    const prompt = new Prompt();
+    try {
+        if (argv.length === 0) {
+            await menuLoop(prompt);
+            return;
+        }
+        if (argv.length > 1) {
+            fail(red('参数太多，一次只接受一个时间。') + dim('\n用法：pcoff 30s / 20m / 1h；不带参数打开菜单；pcoff cancel 取消。'));
+        }
+        const parsed = parseDuration(argv[0] ?? '');
+        if (!parsed) {
+            fail(red(`无法识别的时间：“${argv[0] ?? ''}”`) + dim('\n示例：30s / 20m / 1h / 1h30m；纯数字按秒计。详见 pcoff -h。'));
+        }
+        if (parsed.totalSeconds < 1)
+            fail(red('时间至少 1 秒。'));
+        if (parsed.totalSeconds > MAX_SECONDS)
+            fail(red('时间最长 10 年。'));
+        await scheduleWithCheck(prompt, parsed.totalSeconds);
+    }
+    finally {
+        prompt.close();
+    }
+}
+process.on('SIGINT', exitGracefully);
+main().catch((err) => {
+    console.error(red(`出错了：${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+});

package/dist/menu.js

@@ -0,0 +1,88 @@
+import readline from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { MAX_SECONDS, parseDuration } from './time.js';
+import { cyan, red } from './ui.js';
+/** 交互式问答封装。零依赖，全部基于 node:readline。 */
+export class Prompt {
+    rl = readline.createInterface({ input: stdin, output: stdout });
+    buffered = [];
+    waiter = null;
+    closed = false;
+    constructor() {
+        // 输入可能先于下一次提问到达（例如管道喂入多行），必须排队，否则中间的行会被丢掉
+        this.rl.on('line', (line) => {
+            const waiter = this.waiter;
+            if (waiter) {
+                this.waiter = null;
+                waiter.resolve(line);
+            }
+            else {
+                this.buffered.push(line);
+            }
+        });
+        this.rl.on('close', () => {
+            this.closed = true;
+            const waiter = this.waiter;
+            if (waiter) {
+                this.waiter = null;
+                waiter.reject(new Error('输入流已结束'));
+            }
+        });
+        // readline 处于原始模式时 Ctrl+C 只会触发 'SIGINT' 事件，不会杀掉进程，需要自己接住
+        this.rl.on('SIGINT', () => {
+            stdout.write('\n已退出。已设置的定时关机仍会执行；取消请运行 pcoff cancel。\n');
+            process.exit(0);
+        });
+    }
+    readLine() {
+        const buffered = this.buffered.shift();
+        if (buffered !== undefined)
+            return Promise.resolve(buffered);
+        if (this.closed)
+            return Promise.reject(new Error('输入流已结束'));
+        return new Promise((resolve, reject) => {
+            this.waiter = { resolve, reject };
+        });
+    }
+    async choose(question, min, max) {
+        for (;;) {
+            stdout.write(question);
+            const answer = (await this.readLine()).trim();
+            const value = Number(answer);
+            if (Number.isInteger(value) && value >= min && value <= max)
+                return value;
+            stdout.write(red(`请输入 ${min} ~ ${max} 之间的数字\n`));
+        }
+    }
+    async confirm(question) {
+        for (;;) {
+            stdout.write(`${question} ${cyan('(Y/N) ')}`);
+            const answer = (await this.readLine()).trim().toLowerCase();
+            if (answer === 'y' || answer === 'yes')
+                return true;
+            if (answer === 'n' || answer === 'no')
+                return false;
+            stdout.write(red('请输入 Y 或 N\n'));
+        }
+    }
+    async askDuration() {
+        for (;;) {
+            stdout.write(cyan('请输入时间（如 30s / 20m / 1h / 1h30m，纯数字按秒计）: '));
+            const answer = await this.readLine();
+            const parsed = parseDuration(answer);
+            if (!parsed || parsed.totalSeconds < 1) {
+                stdout.write(red('看不懂这个时间，请参考示例：30s、20m、1h、1h30m\n'));
+                continue;
+            }
+            if (parsed.totalSeconds > MAX_SECONDS) {
+                stdout.write(red('时间最长 10 年。\n'));
+                continue;
+            }
+            return parsed.totalSeconds;
+        }
+    }
+    close() {
+        this.closed = true;
+        this.rl.close();
+    }
+}

package/dist/shutdown.js

@@ -0,0 +1,70 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+/**
+ * Windows：系统已有计划中的关机任务（ERROR_SHUTDOWN_IS_SCHEDULED）。
+ * shutdown.exe 把 Win32 错误码作为进程退出码，因此可以直接用退出码判断。
+ */
+const WERR_SHUTDOWN_IS_SCHEDULED = 1190;
+/** 中文 Windows 的控制台输出是 GBK 系编码，按 UTF-8 解会得到乱码 */
+function decodeOutput(data) {
+    if (!data)
+        return '';
+    if (typeof data === 'string')
+        return data.trim();
+    if (process.platform === 'win32') {
+        try {
+            return new TextDecoder('gb18030').decode(data).trim();
+        }
+        catch {
+            return data.toString('utf8').trim();
+        }
+    }
+    return data.toString('utf8').trim();
+}
+function describe(err) {
+    const e = err;
+    const stderr = decodeOutput(e?.stderr) || (e?.message ?? String(err ?? ''));
+    return { code: e?.code, stderr };
+}
+function isAlreadyScheduled(code, stderr) {
+    return Number(code) === WERR_SHUTDOWN_IS_SCHEDULED || stderr.includes('1190');
+}
+export async function scheduleShutdown(seconds) {
+    if (process.env.PCOFF_DRY_RUN === '1') {
+        return { ok: true, alreadyScheduled: false, stderr: '' };
+    }
+    try {
+        if (process.platform === 'win32') {
+            await exec('shutdown', ['/s', '/t', String(Math.round(seconds)), '/c', 'pcoff 定时关机'], {
+                windowsHide: true,
+                encoding: 'buffer',
+            });
+        }
+        else {
+            // Linux/macOS 的 shutdown 只支持分钟粒度；均需要 root 权限
+            const minutes = Math.max(1, Math.ceil(seconds / 60));
+            await exec('shutdown', ['-h', `+${minutes}`]);
+        }
+        return { ok: true, alreadyScheduled: false, stderr: '' };
+    }
+    catch (err) {
+        const { code, stderr } = describe(err);
+        return { ok: false, alreadyScheduled: isAlreadyScheduled(code, stderr), stderr };
+    }
+}
+export async function abortShutdown() {
+    if (process.env.PCOFF_DRY_RUN === '1') {
+        return { ok: true, nothingPending: false, stderr: '' };
+    }
+    const args = process.platform === 'win32' ? ['/a'] : ['-c'];
+    try {
+        await exec('shutdown', args, { windowsHide: true, encoding: 'buffer' });
+        return { ok: true, nothingPending: false, stderr: '' };
+    }
+    catch (err) {
+        // 失败的最常见原因就是"本来就没有计划中的关机"
+        const { stderr } = describe(err);
+        return { ok: false, nothingPending: true, stderr };
+    }
+}

package/dist/store.js

@@ -0,0 +1,53 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+function taskFile() {
+    const base = process.env.PCOFF_HOME ?? path.join(os.homedir(), '.pcoff');
+    return path.join(base, 'task.json');
+}
+/**
+ * 读取本工具上一次安排且尚未到期的关机记录。
+ * 过期或损坏的记录会被顺手清掉；读不到返回 null。
+ */
+export async function loadActiveTask() {
+    let text;
+    try {
+        text = await fs.readFile(taskFile(), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let task;
+    try {
+        task = JSON.parse(text);
+    }
+    catch {
+        await clearTask();
+        return null;
+    }
+    const fireAt = new Date(task.fireAt);
+    if (Number.isNaN(fireAt.getTime()) || fireAt.getTime() <= Date.now()) {
+        await clearTask();
+        return null;
+    }
+    return task;
+}
+export async function saveTask(seconds) {
+    const now = Date.now();
+    const task = {
+        createdAt: new Date(now).toISOString(),
+        fireAt: new Date(now + seconds * 1000).toISOString(),
+        seconds,
+        platform: process.platform,
+    };
+    await fs.mkdir(path.dirname(taskFile()), { recursive: true });
+    await fs.writeFile(taskFile(), JSON.stringify(task, null, 2) + '\n', 'utf8');
+}
+export async function clearTask() {
+    try {
+        await fs.rm(taskFile(), { force: true });
+    }
+    catch {
+        // 记录文件删不掉不该影响主流程
+    }
+}

package/dist/time.js

@@ -0,0 +1,90 @@
+const UNIT_SECONDS = {
+    s: 1,
+    m: 60,
+    h: 3600,
+    d: 86400,
+};
+// 同前缀的长单位要排在短单位之前，否则 "min" 会被拆成 "m" + "in"
+const UNIT_ALIASES = [
+    ['小时', 'h'],
+    ['hours', 'h'], ['hour', 'h'], ['hrs', 'h'], ['hr', 'h'], ['h', 'h'],
+    ['天', 'd'], ['days', 'd'], ['day', 'd'], ['d', 'd'],
+    ['分钟', 'm'], ['分', 'm'],
+    ['minutes', 'm'], ['mins', 'm'], ['min', 'm'], ['m', 'm'],
+    ['秒钟', 's'], ['秒', 's'],
+    ['seconds', 's'], ['secs', 's'], ['sec', 's'], ['s', 's'],
+];
+/** Windows shutdown /t 的上限：10 年 */
+export const MAX_SECONDS = 315_360_000;
+/**
+ * 解析 "1s" / "20m" / "1h30m" / "90" / "2分30秒" 这类时间表达。
+ * 纯数字按秒处理；无法完整识别时返回 null。
+ */
+export function parseDuration(input) {
+    const raw = input.trim().toLowerCase().replace(/\s+/g, '');
+    if (!raw)
+        return null;
+    if (/^\d+(?:\.\d+)?$/.test(raw)) {
+        const value = Number(raw);
+        if (!Number.isFinite(value))
+            return null;
+        return { totalSeconds: Math.round(value), segments: [{ value, unit: 's' }] };
+    }
+    const segments = [];
+    let rest = raw;
+    while (rest.length > 0) {
+        const matched = /^(\d+(?:\.\d+)?)(.*)$/.exec(rest);
+        if (!matched)
+            return null;
+        const value = Number(matched[1]);
+        const unitPart = matched[2] ?? '';
+        const alias = UNIT_ALIASES.find(([name]) => unitPart.startsWith(name));
+        if (!alias || !Number.isFinite(value))
+            return null;
+        segments.push({ value, unit: alias[1] });
+        rest = unitPart.slice(alias[0].length);
+    }
+    let totalSeconds = 0;
+    for (const seg of segments) {
+        totalSeconds += seg.value * UNIT_SECONDS[seg.unit];
+    }
+    return { totalSeconds: Math.round(totalSeconds), segments };
+}
+/** 90 -> "1 分钟 30 秒"；0 -> "0 秒" */
+export function formatDuration(totalSeconds) {
+    let s = Math.max(0, Math.round(totalSeconds));
+    const d = Math.floor(s / 86400);
+    s -= d * 86400;
+    const h = Math.floor(s / 3600);
+    s -= h * 3600;
+    const m = Math.floor(s / 60);
+    s -= m * 60;
+    const parts = [];
+    if (d > 0)
+        parts.push(`${d} 天`);
+    if (h > 0)
+        parts.push(`${h} 小时`);
+    if (m > 0)
+        parts.push(`${m} 分钟`);
+    if (s > 0 || parts.length === 0)
+        parts.push(`${s} 秒`);
+    return parts.join(' ');
+}
+/** 倒计时用：3661 -> "1:01:01"，59 -> "00:59" */
+export function formatClock(totalSeconds) {
+    const s = Math.max(0, Math.round(totalSeconds));
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const sec = s % 60;
+    const mm = String(m).padStart(2, '0');
+    const ss = String(sec).padStart(2, '0');
+    return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`;
+}
+export function formatTimeOfDay(date) {
+    return date.toLocaleTimeString('zh-CN', {
+        hour12: false,
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    });
+}

package/dist/ui.js

@@ -0,0 +1,10 @@
+const useColor = process.stdout.isTTY === true && !process.env.NO_COLOR;
+function color(code, text) {
+    return useColor ? `\x1b[${code}m${text}\x1b[0m` : text;
+}
+export const bold = (text) => color('1', text);
+export const dim = (text) => color('2', text);
+export const red = (text) => color('31', text);
+export const green = (text) => color('32', text);
+export const yellow = (text) => color('33', text);
+export const cyan = (text) => color('36', text);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "pczzz",
+  "version": "0.0.1",
+  "description": "Timed shutdown command tool",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "pczzz": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "shutdown",
+    "poweroff",
+    "timed shutdown",
+    "windows",
+    "pczzz"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node test/smoke.mjs",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  }
+}