hypercore-cli 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 V.W.
+
+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,110 @@
+# ⚡ Hypercore CLI
+
+AI-Native CLI Shell for productivity — multi-model, production lines, MCP tools, team collaboration.
+
+## Quick Start
+
+```bash
+npm install -g hypercore-cli
+hyper
+```
+
+Or try without installing:
+
+```bash
+npx hypercore-cli
+```
+
+## Features
+
+- **Multi-Model** — Claude, DeepSeek, Gemini, MiniMax, any OpenAI-compatible API
+- **Production Lines** — chain AI agents into automated workflows (YAML config)
+- **MCP Tools** — extend with Model Context Protocol servers
+- **Web Dashboard** — monitor sessions, run lines, view history
+- **Workspace** — browser-based GUI synced with terminal in real-time
+- **Team Mode** — collaborate with teammates via LAN WebSocket
+- **Hyper Network** — skill/need matching across team members
+- **Memory System** — persistent memory extraction across sessions
+- **Hook System** — lifecycle hooks (onSessionStart, onSessionEnd, etc.)
+- **Git-Aware** — branch display, status integration
+
+## Configuration
+
+Create `~/.hypercore/config.toml`:
+
+```toml
+[model]
+provider = "deepseek"          # anthropic | deepseek | gemini | minimax | openai-compatible
+model = "deepseek-coder"
+apiKey = "sk-..."
+
+# Optional: OpenAI-compatible endpoint
+# baseURL = "https://api.example.com/v1"
+```
+
+### Supported Providers
+
+| Provider | Models | Config |
+|----------|--------|--------|
+| Anthropic | Claude Opus, Sonnet, Haiku | `provider = "anthropic"` |
+| DeepSeek | DeepSeek Coder, Chat | `provider = "deepseek"` |
+| Google | Gemini Pro, Flash | `provider = "gemini"` |
+| MiniMax | MiniMax models | `provider = "minimax"` |
+| Any OpenAI-compatible | Via base URL | `provider = "openai-compatible"` |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/dashboard` | Open web dashboard |
+| `/workspace` | Open workspace GUI |
+| `/run <line>` | Run a production line |
+| `/new` | Start new session |
+| `/save` | Save current session |
+| `/cost` | Show token usage and cost |
+| `/memory` | View memory system |
+| `/compact` | Compact conversation context |
+| `/team create` | Create a team |
+| `/team join` | Join a team |
+| `exit` | Exit |
+
+## Production Lines
+
+Define automated workflows in `.hypercore/lines/`:
+
+```yaml
+name: code-review
+description: Automated code review
+stations:
+  - name: analyze
+    agent: claude
+    prompt: "Review the following code for bugs and improvements..."
+  - name: summarize
+    agent: claude
+    prompt: "Summarize the review findings..."
+```
+
+Run with:
+```bash
+hyper run code-review
+```
+
+## MCP Tools
+
+Add MCP servers in `.hypercore/config.toml`:
+
+```toml
+[[mcp]]
+name = "filesystem"
+command = "npx"
+args = ["-y", "@anthropic-ai/mcp-filesystem"]
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+- An API key for at least one supported provider
+
+## License
+
+MIT

package/dist/api-XGC7D5AW.js

@@ -0,0 +1,162 @@
+import {
+  executeRound,
+  gatherProfile,
+  getLatestRound,
+  listRounds,
+  loadAllProfiles,
+  loadNetworkConfig,
+  loadRound,
+  saveNetworkConfig,
+  updateProfileField
+} from "./chunk-U5SGAIMM.js";
+import {
+  parseBody,
+  sendError,
+  sendJSON
+} from "./chunk-AUHU7ALH.js";
+import "./chunk-2LJ2DVEB.js";
+import {
+  loadTeam
+} from "./chunk-6OL3GA3P.js";
+import "./chunk-XOS6HPEF.js";
+import {
+  validateToken
+} from "./chunk-XDRCBMZZ.js";
+import "./chunk-MV4TTRYX.js";
+import "./chunk-IXOIOGR5.js";
+import "./chunk-KRPOPWGA.js";
+import "./chunk-GU2FZQ6A.js";
+import "./chunk-R3GPQC7I.js";
+import "./chunk-BE46C7JW.js";
+import "./chunk-RNG3K465.js";
+import "./chunk-43OLRXM5.js";
+import "./chunk-GOOTEPBK.js";
+import "./chunk-B6A2AKLN.js";
+import "./chunk-V5UHPPSY.js";
+import "./chunk-WHLVZCQY.js";
+import "./chunk-TGTYKBGC.js";
+
+// src/network/api.ts
+function getToken(req) {
+  const auth = req.headers.authorization;
+  if (!auth?.startsWith("Bearer ")) return null;
+  return auth.slice(7);
+}
+async function authenticate(req, teamId) {
+  const token = getToken(req);
+  if (!token) return null;
+  const team = await loadTeam(teamId);
+  if (!team) return null;
+  const member = validateToken(team, token);
+  if (!member) return null;
+  return { memberId: member.id, memberName: member.name };
+}
+async function handleNetworkApiRequest(req, res, config, pathname) {
+  const method = req.method || "GET";
+  const parts = pathname.replace("/api/network/", "").split("/");
+  const teamId = parts[0];
+  const resource = parts[1];
+  const subResource = parts[2];
+  if (!teamId) {
+    sendError(res, "\u7F3A\u5C11 teamId", 400);
+    return;
+  }
+  const auth = await authenticate(req, teamId);
+  if (!auth) {
+    sendError(res, "\u8BA4\u8BC1\u5931\u8D25", 401);
+    return;
+  }
+  if (resource === "profile" && !subResource && method === "GET") {
+    const profile = await gatherProfile(teamId, auth.memberId, auth.memberName);
+    sendJSON(res, { profile });
+    return;
+  }
+  if (resource === "profile" && !subResource && method === "PUT") {
+    const body = await parseBody(req);
+    const field = body.field;
+    const value = body.value;
+    if (!field || !["skills", "needs", "offerings", "customNote"].includes(field)) {
+      sendError(res, "\u65E0\u6548\u5B57\u6BB5\uFF0C\u652F\u6301: skills, needs, offerings, customNote", 400);
+      return;
+    }
+    const profile = await updateProfileField(
+      teamId,
+      auth.memberId,
+      field,
+      value
+    );
+    if (!profile) {
+      sendError(res, "Profile \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u91C7\u96C6", 404);
+      return;
+    }
+    sendJSON(res, { profile });
+    return;
+  }
+  if (resource === "profiles" && method === "GET") {
+    const profiles = await loadAllProfiles(teamId);
+    sendJSON(res, { profiles });
+    return;
+  }
+  if (resource === "run" && method === "POST") {
+    try {
+      const round = await executeRound(teamId, auth.memberId, config);
+      sendJSON(res, { round });
+    } catch (err) {
+      sendError(res, `\u6267\u884C\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return;
+  }
+  if (resource === "rounds" && !subResource && method === "GET") {
+    const rounds = await listRounds(teamId);
+    const summaries = rounds.map((r) => ({
+      id: r.id,
+      status: r.status,
+      startedAt: r.startedAt,
+      completedAt: r.completedAt,
+      triggeredBy: r.triggeredBy,
+      matchCount: r.matches.length,
+      dialogueCount: r.dialogues.length,
+      digestCount: r.digests.length,
+      totalTokenUsage: r.totalTokenUsage,
+      error: r.error
+    }));
+    sendJSON(res, { rounds: summaries });
+    return;
+  }
+  if (resource === "rounds" && subResource && method === "GET") {
+    const round = await loadRound(teamId, subResource);
+    if (!round) {
+      sendError(res, "\u8F6E\u6B21\u4E0D\u5B58\u5728", 404);
+      return;
+    }
+    sendJSON(res, { round });
+    return;
+  }
+  if (resource === "digest" && method === "GET") {
+    const latestRound = await getLatestRound(teamId);
+    if (!latestRound) {
+      sendJSON(res, { digest: null, message: "\u6682\u65E0\u8F6E\u6B21\u8BB0\u5F55" });
+      return;
+    }
+    const myDigest = latestRound.digests.find((d) => d.memberId === auth.memberId);
+    sendJSON(res, { digest: myDigest || null, roundId: latestRound.id });
+    return;
+  }
+  if (resource === "config" && method === "GET") {
+    const netConfig = await loadNetworkConfig(teamId);
+    sendJSON(res, { config: netConfig });
+    return;
+  }
+  if (resource === "config" && method === "PUT") {
+    const body = await parseBody(req);
+    const existing = await loadNetworkConfig(teamId);
+    const updated = { ...existing, ...body };
+    await saveNetworkConfig(teamId, updated);
+    sendJSON(res, { config: updated });
+    return;
+  }
+  sendError(res, "Not Found", 404);
+}
+export {
+  handleNetworkApiRequest
+};

package/dist/auth-DNQWYQKT.js

@@ -0,0 +1,21 @@
+import {
+  clearLocalToken,
+  generateId,
+  generateJoinCode,
+  generateToken,
+  isOwner,
+  loadLocalToken,
+  saveLocalToken,
+  validateToken
+} from "./chunk-XDRCBMZZ.js";
+import "./chunk-V5UHPPSY.js";
+export {
+  clearLocalToken,
+  generateId,
+  generateJoinCode,
+  generateToken,
+  isOwner,
+  loadLocalToken,
+  saveLocalToken,
+  validateToken
+};

package/dist/background-2EGCAAQH.js

@@ -0,0 +1,14 @@
+import {
+  clearCompletedTasks,
+  getTaskOutput,
+  listBackgroundTasks,
+  spawnBackground,
+  stopTask
+} from "./chunk-TGTYKBGC.js";
+export {
+  clearCompletedTasks,
+  getTaskOutput,
+  listBackgroundTasks,
+  spawnBackground,
+  stopTask
+};

package/dist/backlog-Q2NZCLNY.js

@@ -0,0 +1,24 @@
+import {
+  addItem,
+  archiveItem,
+  doneItem,
+  getItem,
+  getStats,
+  listItems,
+  pickItem,
+  reopenItem,
+  updateItem,
+  updateItemMetrics
+} from "./chunk-MGLJ53QN.js";
+export {
+  addItem,
+  archiveItem,
+  doneItem,
+  getItem,
+  getStats,
+  listItems,
+  pickItem,
+  reopenItem,
+  updateItem,
+  updateItemMetrics
+};

package/dist/chunk-2CMSCWQW.js

@@ -0,0 +1,162 @@
+// src/admin/telemetry.ts
+import { join } from "path";
+import { appendFile, stat, rename, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+var HYPERCORE_DIR = join(process.env.HOME || "~", ".hypercore");
+var TELEMETRY_DIR = join(HYPERCORE_DIR, "telemetry");
+var EVENTS_FILE = join(TELEMETRY_DIR, "events.jsonl");
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var enabled = true;
+async function ensureDir() {
+  if (!existsSync(TELEMETRY_DIR)) {
+    await mkdir(TELEMETRY_DIR, { recursive: true });
+  }
+}
+async function rotateIfNeeded() {
+  try {
+    const s = await stat(EVENTS_FILE);
+    if (s.size > MAX_FILE_SIZE) {
+      const archivePath = join(TELEMETRY_DIR, "events.1.jsonl");
+      await rename(EVENTS_FILE, archivePath);
+    }
+  } catch {
+  }
+}
+function trackEvent(event, data = {}) {
+  if (!enabled) return;
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    event,
+    ...data
+  };
+  (async () => {
+    try {
+      await ensureDir();
+      await rotateIfNeeded();
+      await appendFile(EVENTS_FILE, JSON.stringify(entry) + "\n", "utf-8");
+    } catch {
+    }
+  })();
+}
+function trackCmdExec(cmd, args, durationMs, ok, err) {
+  trackEvent("cmd_exec", { cmd, args, duration_ms: durationMs, ok, ...err ? { err } : {} });
+}
+function trackSessionStart(sessionId, model, provider) {
+  trackEvent("session_start", { session_id: sessionId, model, provider });
+}
+function trackSessionEnd(sessionId, rounds, tokensIn, tokensOut, durationMs) {
+  trackEvent("session_end", {
+    session_id: sessionId,
+    rounds,
+    tokens_in: tokensIn,
+    tokens_out: tokensOut,
+    duration_ms: durationMs
+  });
+}
+function trackLineRun(line, topic, durationMs, ok, err) {
+  trackEvent("line_run", { line, topic, duration_ms: durationMs, ok, ...err ? { err } : {} });
+}
+function trackError(errorType, message, sourceFile, cmdContext) {
+  trackEvent("error", {
+    error_type: errorType,
+    message: message.slice(0, 200),
+    // 截断，不存长堆栈
+    source_file: sourceFile,
+    ...cmdContext ? { cmd_context: cmdContext } : {}
+  });
+}
+function trackModelSwitch(fromModel, toModel, ok) {
+  trackEvent("model_switch", { from_model: fromModel, to_model: toModel, ok });
+}
+function trackWebStart(host, port, lanMode) {
+  trackEvent("web_start", { host, port, lan_mode: lanMode });
+}
+function trackTeamAction(action, teamId, memberCount) {
+  trackEvent("team_action", { action, ...teamId ? { team_id: teamId } : {}, ...memberCount != null ? { member_count: memberCount } : {} });
+}
+async function readEvents(days = 7) {
+  const events = [];
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - days);
+  const cutoffStr = cutoff.toISOString();
+  for (const file of [EVENTS_FILE, join(TELEMETRY_DIR, "events.1.jsonl")]) {
+    if (!existsSync(file)) continue;
+    try {
+      const { readFile } = await import("fs/promises");
+      const content = await readFile(file, "utf-8");
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const evt = JSON.parse(line);
+          if (evt.ts >= cutoffStr) {
+            events.push(evt);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return events.sort((a, b) => a.ts.localeCompare(b.ts));
+}
+async function getEventsSummary(days = 7) {
+  const events = await readEvents(days);
+  const eventCounts = {};
+  const cmdCounts = {};
+  let sessionCount = 0;
+  let totalRounds = 0;
+  const errorMap = {};
+  for (const evt of events) {
+    eventCounts[evt.event] = (eventCounts[evt.event] || 0) + 1;
+    if (evt.event === "cmd_exec") {
+      const cmd = String(evt.cmd || "unknown");
+      if (!cmdCounts[cmd]) cmdCounts[cmd] = { total: 0, ok: 0, fail: 0 };
+      cmdCounts[cmd].total++;
+      if (evt.ok) cmdCounts[cmd].ok++;
+      else cmdCounts[cmd].fail++;
+    }
+    if (evt.event === "session_end") {
+      sessionCount++;
+      totalRounds += evt.rounds || 0;
+    }
+    if (evt.event === "error") {
+      const errType = String(evt.error_type || "unknown");
+      errorMap[errType] = (errorMap[errType] || 0) + 1;
+    }
+  }
+  const errors = Object.entries(errorMap).map(([type, count]) => ({ type, count })).sort((a, b) => b.count - a.count);
+  const now = /* @__PURE__ */ new Date();
+  const from = new Date(now);
+  from.setDate(from.getDate() - days);
+  return {
+    totalEvents: events.length,
+    eventCounts,
+    cmdCounts,
+    totalSessions: sessionCount,
+    avgSessionRounds: sessionCount > 0 ? Math.round(totalRounds / sessionCount * 10) / 10 : 0,
+    errors,
+    period: { from: from.toISOString().slice(0, 10), to: now.toISOString().slice(0, 10), days }
+  };
+}
+function setTelemetryEnabled(value) {
+  enabled = value;
+}
+function getEventsFilePath() {
+  return EVENTS_FILE;
+}
+
+export {
+  trackEvent,
+  trackCmdExec,
+  trackSessionStart,
+  trackSessionEnd,
+  trackLineRun,
+  trackError,
+  trackModelSwitch,
+  trackWebStart,
+  trackTeamAction,
+  readEvents,
+  getEventsSummary,
+  setTelemetryEnabled,
+  getEventsFilePath
+};

package/dist/chunk-2LJ2DVEB.js

@@ -0,0 +1,167 @@
+import {
+  loadTeam,
+  updateMemberStatus
+} from "./chunk-6OL3GA3P.js";
+import {
+  validateToken
+} from "./chunk-XDRCBMZZ.js";
+
+// src/web/ws.ts
+import { WebSocketServer, WebSocket } from "ws";
+var clients = /* @__PURE__ */ new Map();
+function getTeamClients(teamId) {
+  return Array.from(clients.values()).filter((c) => c.teamId === teamId);
+}
+function sendToMember(memberId, msg) {
+  const client = clients.get(memberId);
+  if (client && client.ws.readyState === WebSocket.OPEN) {
+    client.ws.send(JSON.stringify(msg));
+    return true;
+  }
+  return false;
+}
+function broadcastToTeam(teamId, msg, excludeId) {
+  for (const client of getTeamClients(teamId)) {
+    if (client.member.id !== excludeId && client.ws.readyState === WebSocket.OPEN) {
+      client.ws.send(JSON.stringify(msg));
+    }
+  }
+}
+function broadcastToAll(teamId, msg) {
+  for (const client of getTeamClients(teamId)) {
+    if (client.ws.readyState === WebSocket.OPEN) {
+      client.ws.send(JSON.stringify(msg));
+    }
+  }
+}
+function makeMsg(type, payload, senderId) {
+  return { type, payload, timestamp: (/* @__PURE__ */ new Date()).toISOString(), senderId };
+}
+var pendingCheckpoints = /* @__PURE__ */ new Map();
+function resolveCheckpoint(runId, stationIndex, response) {
+  const key = `${runId}:${stationIndex}`;
+  const resolver = pendingCheckpoints.get(key);
+  if (resolver) {
+    resolver(response);
+    pendingCheckpoints.delete(key);
+    return true;
+  }
+  return false;
+}
+async function handleMessage(ws, raw) {
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    ws.send(JSON.stringify(makeMsg("auth_fail", { reason: "\u65E0\u6548 JSON" })));
+    return;
+  }
+  const existingClient = Array.from(clients.values()).find((c) => c.ws === ws);
+  if (!existingClient) {
+    if (msg.type !== "auth") {
+      ws.send(JSON.stringify(makeMsg("auth_fail", { reason: "\u8BF7\u5148\u8BA4\u8BC1" })));
+      ws.close();
+      return;
+    }
+    const { teamId: teamId2, token } = msg.payload;
+    const team = await loadTeam(teamId2);
+    if (!team) {
+      ws.send(JSON.stringify(makeMsg("auth_fail", { reason: "\u56E2\u961F\u4E0D\u5B58\u5728" })));
+      ws.close();
+      return;
+    }
+    const member2 = validateToken(team, token);
+    if (!member2) {
+      ws.send(JSON.stringify(makeMsg("auth_fail", { reason: "\u4EE4\u724C\u65E0\u6548" })));
+      ws.close();
+      return;
+    }
+    clients.set(member2.id, { ws, teamId: teamId2, member: member2 });
+    await updateMemberStatus(teamId2, member2.id, "online");
+    ws.send(JSON.stringify(makeMsg("auth_ok", {
+      memberId: member2.id,
+      memberName: member2.name,
+      role: member2.role,
+      teamName: team.name
+    })));
+    broadcastToTeam(teamId2, makeMsg("member_joined", {
+      memberId: member2.id,
+      memberName: member2.name
+    }), member2.id);
+    return;
+  }
+  const { teamId, member } = existingClient;
+  switch (msg.type) {
+    // ----- 任务事件 -----
+    case "task_created":
+    case "task_updated":
+    case "task_deleted":
+      broadcastToTeam(teamId, makeMsg(msg.type, msg.payload, member.id), member.id);
+      break;
+    // ----- 检查点响应 -----
+    case "run_checkpoint_response": {
+      const { runId, stationIndex, action, feedback } = msg.payload;
+      resolveCheckpoint(runId, stationIndex, { action, feedback });
+      break;
+    }
+    // ----- 聊天消息 -----
+    case "chat_message": {
+      const { content } = msg.payload;
+      broadcastToAll(teamId, makeMsg("chat_message", {
+        senderId: member.id,
+        senderName: member.name,
+        content
+      }));
+      break;
+    }
+    case "chat_typing": {
+      broadcastToTeam(teamId, makeMsg("chat_typing", {
+        memberId: member.id,
+        memberName: member.name
+      }), member.id);
+      break;
+    }
+    default:
+      break;
+  }
+}
+function attachWebSocket(_server, _config) {
+  const wss = new WebSocketServer({ noServer: true });
+  wss.on("connection", (ws) => {
+    ws.on("message", (data) => {
+      handleMessage(ws, data.toString()).catch((err) => {
+        console.error("[WS] \u5904\u7406\u6D88\u606F\u9519\u8BEF:", err);
+      });
+    });
+    ws.on("close", async () => {
+      for (const [memberId, client] of clients.entries()) {
+        if (client.ws === ws) {
+          clients.delete(memberId);
+          await updateMemberStatus(client.teamId, memberId, "offline");
+          broadcastToTeam(client.teamId, makeMsg("member_left", {
+            memberId,
+            memberName: client.member.name
+          }));
+          break;
+        }
+      }
+    });
+    ws.on("error", (err) => {
+      console.error("[WS] \u8FDE\u63A5\u9519\u8BEF:", err.message);
+    });
+    setTimeout(() => {
+      const isAuthed = Array.from(clients.values()).some((c) => c.ws === ws);
+      if (!isAuthed && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(makeMsg("auth_fail", { reason: "\u8BA4\u8BC1\u8D85\u65F6" })));
+        ws.close();
+      }
+    }, 1e4);
+  });
+  return wss;
+}
+
+export {
+  sendToMember,
+  broadcastToTeam,
+  attachWebSocket
+};