je-cd 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 joke-lx
+
+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,78 @@
+# jc — j 命令套件
+
+> 跨平台系统快捷命令集。将 Windows batch 版 `j` 命令套件移植为纯 TypeScript 跨平台 npm CLI。
+
+## 安装
+
+```bash
+npm install -g jc
+```
+
+## 用法
+
+```bash
+jc                    # 显示帮助
+jc l                  # 列出所有组
+
+jc claude             # 启动 Claude Code
+jc claude b           # 跳过权限模式
+jc claude r           # 恢复上次会话
+
+jc happy              # 启动 Happy Claude
+jc happy daemon       # Happy 守护进程模式
+
+jc w l                # 列出 w 组 11 个类别
+jc w l proc           # 进程类命令列表
+jc w p 3306           # 查 3306 端口占用
+jc w pk 8080          # 一键查杀 8080 端口进程
+jc w k 1234           # 按 PID 杀进程
+jc w top              # CPU 占用 Top20
+jc w sysinfo          # 系统详细信息
+jc w cpu              # CPU 信息
+jc w disk             # 磁盘卷信息
+jc w ip               # 网络接口信息
+jc w wifi             # Wi-Fi 连接信息
+jc w mac              # MAC 地址
+jc w who              # 当前用户信息
+jc w ?                # 命令帮助
+```
+
+## 分组
+
+| 组 | 别名 | 说明 | 命令数 |
+|----|------|------|--------|
+| claude | c | Claude Code CLI 包装 | 4 |
+| happy | hy | Happy mobile Claude 包装 | 7 |
+| w | w | 系统快捷命令集 | 87 |
+
+## w 组 11 个类别
+
+| 类别 | 命令数 | 说明 |
+|------|--------|------|
+| proc | 8 | 进程管理（端口/查杀/Top） |
+| net | 15 | 网络（IP/DNS/WiFi/路由） |
+| file | 13 | 文件操作（ls/cd/find/size） |
+| sys | 12 | 系统信息（CPU/内存/磁盘/GPU） |
+| svc | 5 | 服务管理 |
+| pwr | 6 | 电源（关机/重启/锁屏/休眠） |
+| reg | 4 | 注册表（仅 Windows） |
+| task | 3 | 计划任务（仅 Windows） |
+| tools | 14 | 系统工具（任务管理器/控制面板等） |
+| user | 4 | 用户/权限 |
+| wsl | 3 | WSL/Docker（仅 Windows） |
+
+## 跨平台
+
+- **Windows**: 全部 98 命令完整支持
+- **macOS / Linux**: 核心命令支持（~80%），注册表/WSL/WiFi密码等 Windows 特有命令会提示"此命令仅支持 Windows"
+
+## 构建
+
+```bash
+npm run build   # tsup 打包
+npm test        # Vitest 测试
+```
+
+## 许可证
+
+MIT

package/dist/adapter-DN3PLEN3.js

@@ -0,0 +1,18 @@
+import {
+  getCpuManager,
+  getDiskManager,
+  getGpuManager,
+  getMemoryManager,
+  getNetworkManager,
+  getOsManager,
+  getProcessManager
+} from "./chunk-DZZGI7AU.js";
+export {
+  getCpuManager,
+  getDiskManager,
+  getGpuManager,
+  getMemoryManager,
+  getNetworkManager,
+  getOsManager,
+  getProcessManager
+};

package/dist/chunk-DZZGI7AU.js

@@ -0,0 +1,405 @@
+// src/shared/system/process.ts
+import si from "systeminformation";
+import { execSync } from "child_process";
+var WinProcessManager = class {
+  async getListeningPorts() {
+    const data = await si.networkConnections();
+    const listenEntries = data && data.length > 0 ? data.filter((c) => c.state === "listen") : [];
+    if (listenEntries.length > 0) {
+      return listenEntries.map((c) => ({
+        pid: c.pid,
+        name: "",
+        cpu: 0,
+        memory: 0,
+        port: c.localPort,
+        state: c.state
+      }));
+    }
+    if (process.platform === "win32") {
+      try {
+        const output = execSync("netstat -ano", { encoding: "utf8", timeout: 5e3 });
+        return output.split("\n").filter((l) => l.includes("LISTENING")).map((l) => {
+          const parts = l.trim().split(/\s+/);
+          const addr = parts[1] || "";
+          const port = parseInt(addr.split(":").pop() || "", 10);
+          const pid = parseInt(parts[parts.length - 1], 10);
+          return { pid: isNaN(pid) ? 0 : pid, name: "", cpu: 0, memory: 0, port: isNaN(port) ? void 0 : port, state: "listen" };
+        }).filter((p) => p.port !== void 0 && p.pid > 0);
+      } catch {
+      }
+    }
+    return [];
+  }
+  async getProcessByPort(port) {
+    let conns = await si.networkConnections();
+    if (!conns || conns.length === 0 || !conns.some((c) => c.state === "listen")) {
+      if (process.platform === "win32") {
+        try {
+          const output = execSync("netstat -ano", { encoding: "utf8", timeout: 5e3 });
+          conns = output.split("\n").filter((l) => l.includes("LISTENING")).map((l) => {
+            const parts = l.trim().split(/\s+/);
+            const addr = parts[1] || "";
+            const localPort = parseInt(addr.split(":").pop() || "", 10);
+            const pid = parseInt(parts[parts.length - 1], 10);
+            return { localPort, pid, state: "listen" };
+          });
+        } catch {
+        }
+      }
+    }
+    const matches = conns.filter((c) => c.localPort === port && c.state === "listen");
+    if (matches.length === 0) return [];
+    return Promise.all(matches.map(async (m) => {
+      const proc = await this.getProcessInfo(m.pid);
+      return { ...proc, port: m.localPort };
+    }));
+  }
+  async getProcessByName(name) {
+    const processes = await si.processes();
+    return processes.list.filter((p) => p.name.toLowerCase().includes(name.toLowerCase())).map((p) => ({
+      pid: p.pid,
+      name: p.name,
+      cpu: p.cpu,
+      memory: Math.round(p.mem / (1024 * 1024)),
+      state: p.state
+    }));
+  }
+  async killProcess(pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      process.kill(pid, "SIGKILL");
+    }
+  }
+  async getTopProcesses(sort, limit) {
+    const processes = await si.processes();
+    const list = processes.list.map((p) => ({
+      pid: p.pid,
+      name: p.name,
+      cpu: p.cpu,
+      memory: Math.round(p.mem / (1024 * 1024)),
+      state: p.state
+    }));
+    if (sort === "cpu") {
+      list.sort((a, b) => b.cpu - a.cpu);
+    } else {
+      list.sort((a, b) => b.memory - a.memory);
+    }
+    return list.slice(0, limit);
+  }
+  async getProcessStats() {
+    const processes = await si.processes();
+    return {
+      total: processes.all,
+      running: processes.running || processes.all,
+      cpuPercent: Math.round((typeof processes.cpu === "number" ? processes.cpu : 0) * 10) / 10,
+      memoryGB: Math.round((typeof processes.mem === "number" ? processes.mem : 0) / (1024 * 1024 * 1024) * 10) / 10
+    };
+  }
+  async listProcesses(nameFilter) {
+    const processes = await si.processes();
+    let list = processes.list;
+    if (nameFilter) {
+      list = list.filter((p) => p.name.toLowerCase().includes(nameFilter.toLowerCase()));
+    }
+    return list.map((p) => ({
+      pid: p.pid,
+      name: p.name,
+      cpu: p.cpu,
+      memory: Math.round(p.mem / (1024 * 1024)),
+      state: p.state
+    }));
+  }
+  async getProcessInfo(pid) {
+    try {
+      const procs = await si.processes();
+      const p = procs.list.find((x) => x.pid === pid);
+      if (p) {
+        return { pid, name: p.name, cpu: p.cpu, memory: Math.round(p.mem / (1024 * 1024)) };
+      }
+    } catch {
+    }
+    return { pid, name: `PID:${pid}`, cpu: 0, memory: 0 };
+  }
+};
+
+// src/shared/system/network.ts
+import si2 from "systeminformation";
+import { execSync as execSync2 } from "child_process";
+var SystemNetworkManager = class {
+  async getNetworkInfo() {
+    const [interfaces, defaultGateway] = await Promise.all([
+      si2.networkInterfaces(),
+      si2.networkGatewayDefault()
+    ]);
+    const ifaces = (interfaces || []).map((inf) => ({
+      name: inf.iface,
+      ip4: inf.ip4,
+      ip6: inf.ip6,
+      mac: inf.mac,
+      type: inf.type
+    }));
+    const dns = await this.getDnsServers();
+    return {
+      interfaces: ifaces,
+      defaultGateway: defaultGateway || "",
+      dnsServers: dns,
+      hostname: (await si2.osInfo()).hostname
+    };
+  }
+  async getDnsServers() {
+    try {
+      const dns = await si2.dns();
+      return dns.nameservers || [];
+    } catch {
+      return [];
+    }
+  }
+  async getWiFiInfo() {
+    try {
+      const networks = await si2.wifiConnections();
+      return (networks || []).map((n) => ({
+        ssid: n.ssid || "",
+        signal: n.signal || 0,
+        frequency: n.frequency || "",
+        channel: n.channel || 0,
+        security: n.security || ""
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getWiFiPasswords() {
+    if (process.platform !== "win32") {
+      throw new Error("\u6B64\u547D\u4EE4\u4EC5\u652F\u6301 Windows");
+    }
+    const profiles = [];
+    try {
+      const output = execSync2("netsh wlan show profiles", { encoding: "utf8" });
+      const lines = output.split("\n");
+      const ssids = [];
+      for (const line of lines) {
+        const m = line.match(/:\s*(.+)$/);
+        if (m) ssids.push(m[1].trim());
+      }
+      for (const ssid of ssids) {
+        try {
+          const detail = execSync2(`netsh wlan show profile "${ssid}" key=clear`, { encoding: "utf8" });
+          const pwMatch = detail.match(/关键内容\s*:\s*(.+)$/m) || detail.match(/Key Content\s*:\s*(.+)$/m);
+          profiles.push({ ssid, password: pwMatch ? pwMatch[1].trim() : "(\u65E0)" });
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return profiles;
+  }
+  async ping(host) {
+    const flag = process.platform === "win32" ? "-n" : "-c";
+    try {
+      const start = Date.now();
+      execSync2(`ping ${flag} 1 ${host}`, { encoding: "utf8", timeout: 1e4 });
+      return { alive: true, time: Date.now() - start };
+    } catch {
+      return { alive: false, time: 0 };
+    }
+  }
+  async traceRoute(host) {
+    const cmd = process.platform === "win32" ? `tracert -d ${host}` : `traceroute -n ${host}`;
+    try {
+      const output = execSync2(cmd, { encoding: "utf8", timeout: 3e4 });
+      return output.split("\n").filter((l) => l.trim()).slice(1);
+    } catch {
+      return [];
+    }
+  }
+  async getConnections() {
+    const data = await si2.networkConnections();
+    return (data || []).map((c) => ({
+      localPort: c.localPort,
+      remotePort: c.remotePort,
+      state: c.state,
+      pid: c.pid
+    }));
+  }
+  async flushDns() {
+    if (process.platform === "win32") {
+      execSync2("ipconfig /flushdns", { encoding: "utf8" });
+    } else if (process.platform === "darwin") {
+      execSync2("dscacheutil -flushcache", { encoding: "utf8" });
+    } else {
+      execSync2("systemd-resolve --flush-caches || resolvectl flush-caches", { encoding: "utf8" });
+    }
+  }
+  async getProxySettings() {
+    if (process.platform === "win32") {
+      try {
+        const output = execSync2('reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyEnable /t REG_DWORD', { encoding: "utf8" });
+        const enabled = output.includes("0x1");
+        let httpProxy2 = "";
+        let httpsProxy2 = "";
+        if (enabled) {
+          try {
+            const server = execSync2('reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyServer /t REG_SZ', { encoding: "utf8" });
+            const m = server.match(/:\s*(.+)$/m);
+            if (m) {
+              httpProxy2 = m[1].trim();
+              httpsProxy2 = m[1].trim();
+            }
+          } catch {
+          }
+        }
+        return { httpProxy: httpProxy2, httpsProxy: httpsProxy2, enabled };
+      } catch {
+        return { httpProxy: "", httpsProxy: "", enabled: false };
+      }
+    }
+    const httpProxy = process.env.http_proxy || process.env.HTTP_PROXY || "";
+    const httpsProxy = process.env.https_proxy || process.env.HTTPS_PROXY || "";
+    return { httpProxy, httpsProxy, enabled: !!(httpProxy || httpsProxy) };
+  }
+  async getMacAddresses() {
+    const ifs = await si2.networkInterfaces();
+    return (ifs || []).map((i) => ({ name: i.iface, mac: i.mac }));
+  }
+};
+
+// src/shared/system/cpu.ts
+import si3 from "systeminformation";
+var SystemCpuManager = class {
+  async getInfo() {
+    const [cpu, load] = await Promise.all([
+      si3.cpu(),
+      si3.currentLoad()
+    ]);
+    return {
+      manufacturer: cpu.manufacturer,
+      brand: cpu.brand,
+      physicalCores: cpu.physicalCores,
+      logicalCores: cpu.cores,
+      speedGHz: cpu.speed,
+      loadPercent: Math.round(load.currentLoad * 10) / 10
+    };
+  }
+};
+
+// src/shared/system/memory.ts
+import si4 from "systeminformation";
+var SystemMemoryManager = class {
+  async getInfo() {
+    const mem = await si4.mem();
+    return {
+      totalGB: Math.round(mem.total / (1024 * 1024 * 1024) * 10) / 10,
+      freeGB: Math.round(mem.free / (1024 * 1024 * 1024) * 10) / 10,
+      usedGB: Math.round(mem.used / (1024 * 1024 * 1024) * 10) / 10,
+      percentUsed: Math.round(mem.used / mem.total * 100 * 10) / 10,
+      swapTotalGB: Math.round(mem.swaptotal / (1024 * 1024 * 1024) * 10) / 10,
+      swapUsedGB: Math.round(mem.swapused / (1024 * 1024 * 1024) * 10) / 10
+    };
+  }
+};
+
+// src/shared/system/disk.ts
+import si5 from "systeminformation";
+var SystemDiskManager = class {
+  async getInfo() {
+    const fs = await si5.fsSize();
+    return fs.filter((f) => f.mount).map((f) => ({
+      drive: f.mount,
+      sizeGB: Math.round(f.size / (1024 * 1024 * 1024)),
+      usedGB: Math.round(f.used / (1024 * 1024 * 1024)),
+      freeGB: Math.round((f.size - f.used) / (1024 * 1024 * 1024)),
+      percentUsed: Math.round(f.use * 10) / 10,
+      filesystem: f.fs || ""
+    }));
+  }
+  async getFullInfo() {
+    return this.getInfo();
+  }
+  async getSize(path) {
+    const fs = await si5.fsSize(path);
+    const total = fs.reduce((acc, f) => acc + f.size, 0);
+    return { sizeMB: Math.round(total / (1024 * 1024)) };
+  }
+};
+
+// src/shared/system/gpu.ts
+import si6 from "systeminformation";
+var SystemGpuManager = class {
+  async getInfo() {
+    const graphics = await si6.graphics();
+    return (graphics.controllers || []).map((g) => ({
+      model: g.model,
+      driverVersion: g.driverVersion || "",
+      vramGB: Math.round((g.vram || 0) / 1024 * 10) / 10
+    }));
+  }
+};
+
+// src/shared/system/os.ts
+import si7 from "systeminformation";
+var SystemOsManager = class {
+  async getInfo() {
+    const [os, bios, time] = await Promise.all([
+      si7.osInfo(),
+      si7.bios(),
+      si7.time()
+    ]);
+    return {
+      hostname: os.hostname,
+      platform: os.platform,
+      distro: os.distro,
+      release: os.release,
+      kernel: os.kernel,
+      uptime: time.uptime,
+      biosVendor: bios.vendor || "",
+      biosVersion: bios.version || "",
+      biosDate: bios.releaseDate || ""
+    };
+  }
+  async getHostname() {
+    return (await si7.osInfo()).hostname;
+  }
+  async getUptime() {
+    const t = (await si7.time()).uptime;
+    const d = Math.floor(t / 86400);
+    const h = Math.floor(t % 86400 / 3600);
+    const m = Math.floor(t % 3600 / 60);
+    if (d > 0) return `${d}d ${h}h ${m}m`;
+    if (h > 0) return `${h}h ${m}m`;
+    return `${m}m`;
+  }
+};
+
+// src/shared/system/adapter.ts
+function getProcessManager() {
+  return new WinProcessManager();
+}
+function getNetworkManager() {
+  return new SystemNetworkManager();
+}
+function getCpuManager() {
+  return new SystemCpuManager();
+}
+function getMemoryManager() {
+  return new SystemMemoryManager();
+}
+function getDiskManager() {
+  return new SystemDiskManager();
+}
+function getGpuManager() {
+  return new SystemGpuManager();
+}
+function getOsManager() {
+  return new SystemOsManager();
+}
+
+export {
+  getProcessManager,
+  getNetworkManager,
+  getCpuManager,
+  getMemoryManager,
+  getDiskManager,
+  getGpuManager,
+  getOsManager
+};