@zonease/happy 0.6.38 → 0.6.40

package/dist/ssh-yMllSHu5.cjs

@@ -0,0 +1,365 @@
+'use strict';
+
+var socket_ioClient = require('socket.io-client');
+var logger = require('./persistence-CBTtC_dm.cjs');
+var deviceKeys = require('./deviceKeys-C540DcXl.cjs');
+var controlClient = require('./controlClient-B23M-WPp.cjs');
+require('node:fs/promises');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('chalk');
+require('fs');
+require('axios');
+require('./auth-C7ZScWEw.cjs');
+require('qrcode-terminal');
+require('./time-Bj2HRkKH.cjs');
+require('./browser-DzgO4oaD.cjs');
+require('open');
+require('react');
+require('ink');
+require('./projectPath-ChLhdOyt.cjs');
+require('path');
+require('url');
+
+function matchDevice(devices, query) {
+  const lowered = query.trim().toLowerCase();
+  return devices.find((device) => device.id === query) ?? devices.find((device) => device.name.toLowerCase() === lowered) ?? devices.find((device) => device.name.toLowerCase().startsWith(lowered)) ?? devices.find((device) => device.name.toLowerCase().includes(lowered)) ?? null;
+}
+const DEFAULT_COMMAND_TIMEOUT_MS = 3e5;
+function parseSshArgs(args) {
+  const separator = args.indexOf("--");
+  const head = separator >= 0 ? args.slice(0, separator) : args;
+  const command = separator >= 0 ? args.slice(separator + 1).join(" ") : null;
+  let target = null;
+  let timeoutMs = DEFAULT_COMMAND_TIMEOUT_MS;
+  let stream = false;
+  for (let i = 0; i < head.length; i++) {
+    if (head[i] === "--stream" || head[i] === "-s") {
+      stream = true;
+      continue;
+    }
+    if (head[i] === "--timeout" || head[i] === "-t") {
+      const seconds = Number(head[++i]);
+      if (Number.isFinite(seconds) && seconds > 0) timeoutMs = seconds * 1e3;
+      continue;
+    }
+    if (!target && !head[i].startsWith("-")) target = head[i];
+  }
+  return { target, command: command && command.trim() ? command : null, timeoutMs, stream };
+}
+async function resolveFromCache(query) {
+  const names = await deviceKeys.readCachedDeviceNames();
+  const id = pickCachedDeviceId(names, query);
+  if (!id) return null;
+  const material = await deviceKeys.readCachedDeviceKey(id);
+  return material ? { device: { id, name: names[id] }, ...material } : null;
+}
+function pickCachedDeviceId(names, query) {
+  if (names[query]) return query;
+  const lowered = query.trim().toLowerCase();
+  for (const test of [
+    (name) => name === lowered,
+    (name) => name.startsWith(lowered),
+    (name) => name.includes(lowered)
+  ]) {
+    const matches = Object.keys(names).filter((id) => test(names[id].toLowerCase()));
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) return null;
+  }
+  return null;
+}
+async function resolveFromServer(credentials, query) {
+  const { devices } = await listDevicesWithNames(credentials);
+  const device = matchDevice(devices, query);
+  if (!device) {
+    console.error(`No enrolled device matches "${query}". Run "happy ssh" with no arguments to list devices.`);
+    return null;
+  }
+  if (!device.active) {
+    console.error(`Device "${device.name}" is offline.`);
+    return null;
+  }
+  const { key, variant } = await deviceKeys.ensureDeviceKey(credentials, device.id, () => {
+    console.error("Waiting for approval in the Happy app (Devices \u2192 pending request)...");
+  });
+  await deviceKeys.pruneDeviceAliases(device.id, device.name);
+  return { device, key, variant };
+}
+async function runOnDevice(credentials, query, command, options = {}) {
+  const cached = await resolveFromCache(query);
+  const resolved = cached ?? await resolveFromServer(credentials, query);
+  if (!resolved) return 1;
+  if (options.stream) {
+    return await streamOnResolved(credentials, resolved, command, options);
+  }
+  const viaDaemon = await controlClient.execOnDeviceViaDaemon(
+    resolved.device.id,
+    command,
+    options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS
+  ).catch(() => null);
+  if (viaDaemon) {
+    return reportResult(viaDaemon);
+  }
+  try {
+    return await execOnResolved(credentials, resolved, command, options);
+  } catch (error) {
+    if (!cached) throw error;
+    const fresh = await resolveFromServer(credentials, query);
+    if (!fresh) return 1;
+    return await execOnResolved(credentials, fresh, command, options);
+  }
+}
+function reportResult(result) {
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.error && !result.error.startsWith("Command failed:")) {
+    console.error(result.error);
+  }
+  return result.exitCode ?? (result.success ? 0 : 1);
+}
+async function streamOnResolved(credentials, { device, key, variant }, command, options) {
+  const socket = socket_ioClient.io(logger.configuration.serverUrl, {
+    auth: { token: credentials.token, clientType: "user-scoped" },
+    path: "/v1/updates",
+    transports: ["websocket"]
+  });
+  await new Promise((resolve, reject) => {
+    socket.once("connect", () => resolve());
+    socket.once("connect_error", reject);
+  });
+  const timeoutMs = options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+  try {
+    const answer = await socket.timeout(3e4).emitWithAck("rpc-call", {
+      method: `${device.id}:pty-start`,
+      params: logger.encodeBase64(logger.encrypt(key, variant, {
+        cols: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24,
+        exec: { command, timeoutMs }
+      }))
+    });
+    if (!answer?.ok) throw new Error(answer?.error || "pty-start failed");
+    const started = logger.decrypt(key, variant, logger.decodeBase64(answer.result));
+    if (!started?.ok || !started.ptyId) {
+      throw new Error(started?.error ?? "Device refused to start the command");
+    }
+    return await new Promise((resolve) => {
+      const execId = started.ptyId;
+      const guard = setTimeout(() => resolve(1), timeoutMs + 3e4);
+      socket.on("pty-output", (envelope) => {
+        if (envelope?.sessionId !== device.id || envelope?.ptyId !== execId) return;
+        try {
+          const frame = logger.decrypt(key, variant, logger.decodeBase64(envelope.data));
+          if (typeof frame?.chunk !== "string") return;
+          const target = frame.stream === "stderr" ? process.stderr : process.stdout;
+          target.write(Buffer.from(frame.chunk, "base64"));
+        } catch {
+        }
+      });
+      socket.on("pty-exit", (envelope) => {
+        if (envelope?.sessionId !== device.id || envelope?.ptyId !== execId) return;
+        clearTimeout(guard);
+        resolve(typeof envelope.exitCode === "number" ? envelope.exitCode : 1);
+      });
+      socket.on("disconnect", () => {
+        clearTimeout(guard);
+        resolve(1);
+      });
+    });
+  } finally {
+    socket.close();
+  }
+}
+async function execOnResolved(credentials, { device, key, variant }, command, options) {
+  const socket = socket_ioClient.io(logger.configuration.serverUrl, {
+    auth: { token: credentials.token, clientType: "user-scoped" },
+    path: "/v1/updates",
+    transports: ["websocket"]
+  });
+  await new Promise((resolve, reject) => {
+    socket.once("connect", () => resolve());
+    socket.once("connect_error", reject);
+  });
+  try {
+    const result = await deviceKeys.deviceExec(socket, credentials, device.id, command, {
+      deviceKeyBase64: logger.encodeBase64(key),
+      deviceKeyVariant: variant,
+      timeout: options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
+      // matchDevice already read the listing and rejected offline devices.
+      skipMachineLookup: true
+    });
+    return reportResult(result);
+  } finally {
+    socket.close();
+  }
+}
+async function sshDevice(credentials, query) {
+  const { devices } = await listDevicesWithNames(credentials);
+  const device = matchDevice(devices, query);
+  if (!device) {
+    console.error(`No enrolled device matches "${query}". Run "happy ssh" with no arguments to list devices.`);
+    return 1;
+  }
+  if (!device.active) {
+    console.error(`Device "${device.name}" is offline.`);
+    return 1;
+  }
+  const { key, variant } = await deviceKeys.ensureDeviceKey(credentials, device.id, () => {
+    console.log("Waiting for approval in the Happy app (Devices \u2192 pending request)...");
+  });
+  const socket = socket_ioClient.io(logger.configuration.serverUrl, {
+    auth: { token: credentials.token, clientType: "user-scoped" },
+    path: "/v1/updates",
+    transports: ["websocket"]
+  });
+  await new Promise((resolve, reject) => {
+    socket.once("connect", () => resolve());
+    socket.once("connect_error", reject);
+  });
+  const rpc = async (method, params) => {
+    const answer = await socket.timeout(3e4).emitWithAck("rpc-call", {
+      method: `${device.id}:${method}`,
+      params: logger.encodeBase64(logger.encrypt(key, variant, params))
+    });
+    if (!answer?.ok) throw new Error(answer?.error || `${method} failed`);
+    return logger.decrypt(key, variant, logger.decodeBase64(answer.result));
+  };
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  const started = await rpc("pty-start", { cols, rows });
+  if (!started?.ok || !started.ptyId) {
+    socket.close();
+    console.error(`Could not open a shell on "${device.name}": ${started?.error ?? "unknown error"}`);
+    return 1;
+  }
+  const ptyId = started.ptyId;
+  let exitCode = 0;
+  const cleanup = () => {
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.pause();
+    socket.close();
+  };
+  await new Promise((resolve) => {
+    socket.on("pty-output", (envelope) => {
+      if (envelope?.sessionId !== device.id || envelope?.ptyId !== ptyId) return;
+      try {
+        const data = logger.decrypt(key, variant, logger.decodeBase64(envelope.data));
+        if (typeof data === "string") process.stdout.write(Buffer.from(data, "base64"));
+      } catch {
+      }
+    });
+    socket.on("pty-exit", (envelope) => {
+      if (envelope?.sessionId !== device.id || envelope?.ptyId !== ptyId) return;
+      exitCode = typeof envelope.exitCode === "number" ? envelope.exitCode : 0;
+      resolve();
+    });
+    socket.on("disconnect", () => resolve());
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (chunk) => {
+      socket.volatile.emit("pty-input", {
+        sessionId: device.id,
+        ptyId,
+        data: logger.encodeBase64(logger.encrypt(key, variant, chunk.toString("utf8")))
+      });
+    });
+    process.stdout.on("resize", () => {
+      void rpc("pty-resize", {
+        ptyId,
+        cols: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24
+      }).catch(() => {
+      });
+    });
+  });
+  await rpc("pty-close", { ptyId }).catch(() => {
+  });
+  cleanup();
+  return exitCode;
+}
+function pickDevice(devices) {
+  const selectable = devices.filter((device) => device.active);
+  if (selectable.length === 0) {
+    console.log("No devices are online right now.");
+    return Promise.resolve(null);
+  }
+  if (selectable.length === 1) {
+    return Promise.resolve(selectable[0]);
+  }
+  return new Promise((resolve) => {
+    let index = 0;
+    let rendered = 0;
+    const render = () => {
+      if (rendered > 0) process.stdout.write(`\x1B[${rendered}A`);
+      const lines = selectable.map((device, position) => {
+        const marker = position === index ? "\x1B[36m>\x1B[0m" : " ";
+        const name = position === index ? `\x1B[1m${device.name}\x1B[0m` : device.name;
+        return `\x1B[2K ${marker} ${name}${device.platform ? `  \x1B[2m${device.platform}\x1B[0m` : ""}`;
+      });
+      process.stdout.write(lines.join("\n") + "\n");
+      rendered = lines.length;
+    };
+    const finish = (device) => {
+      process.stdin.off("data", onData);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      resolve(device);
+    };
+    const onData = (chunk) => {
+      const key = chunk.toString();
+      if (key === "\x1B[A" || key === "k") {
+        index = (index - 1 + selectable.length) % selectable.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        index = (index + 1) % selectable.length;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        finish(selectable[index]);
+      } else if (key === "" || key === "\x1B" || key === "q") {
+        console.log("Cancelled.");
+        finish(null);
+      }
+    };
+    console.log("Select a device (\u2191/\u2193, Enter to connect, q to cancel):");
+    render();
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+async function listDevicesWithNames(credentials) {
+  const [devices, names] = await Promise.all([deviceKeys.listDevices(credentials), deviceKeys.readCachedDeviceNames()]);
+  let named = false;
+  const withNames = devices.map((device) => {
+    const cached = names[device.id];
+    if (cached) named = true;
+    return cached ? { ...device, name: cached } : device;
+  });
+  return { devices: withNames, named };
+}
+async function sshPickAndConnect(credentials) {
+  const { devices } = await listDevicesWithNames(credentials);
+  if (devices.length === 0) {
+    console.log("No devices enrolled yet. Add one from Happy \u2192 Devices.");
+    return 0;
+  }
+  if (!process.stdin.isTTY) {
+    for (const device of devices) {
+      console.log(`${device.active ? "online " : "offline"}  ${device.name}${device.platform ? `  (${device.platform})` : ""}`);
+    }
+    console.log("\nUsage: happy ssh <device>");
+    return 0;
+  }
+  const chosen = await pickDevice(devices);
+  if (!chosen) return 0;
+  return await sshDevice(credentials, chosen.id);
+}
+
+exports.parseSshArgs = parseSshArgs;
+exports.pickCachedDeviceId = pickCachedDeviceId;
+exports.runOnDevice = runOnDevice;
+exports.sshDevice = sshDevice;
+exports.sshPickAndConnect = sshPickAndConnect;

package/dist/systemdScope-BeOtAkhk.mjs

@@ -0,0 +1,25 @@
+import { join } from 'node:path';
+import os from 'node:os';
+
+const SERVICE_NAME = "happy-daemon.service";
+function systemdScopeFor(isRoot) {
+  if (isRoot) {
+    return {
+      system: true,
+      unitPath: join("/etc/systemd/system", SERVICE_NAME),
+      systemctlFlag: "",
+      wantedBy: "multi-user.target"
+    };
+  }
+  return {
+    system: false,
+    unitPath: join(os.homedir(), ".config", "systemd", "user", SERVICE_NAME),
+    systemctlFlag: "--user",
+    wantedBy: "default.target"
+  };
+}
+function isRootUser() {
+  return typeof process.getuid === "function" && process.getuid() === 0;
+}
+
+export { SERVICE_NAME as S, isRootUser as i, systemdScopeFor as s };

package/dist/systemdScope-DW3-UoKB.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var path = require('node:path');
+var os = require('node:os');
+
+const SERVICE_NAME = "happy-daemon.service";
+function systemdScopeFor(isRoot) {
+  if (isRoot) {
+    return {
+      system: true,
+      unitPath: path.join("/etc/systemd/system", SERVICE_NAME),
+      systemctlFlag: "",
+      wantedBy: "multi-user.target"
+    };
+  }
+  return {
+    system: false,
+    unitPath: path.join(os.homedir(), ".config", "systemd", "user", SERVICE_NAME),
+    systemctlFlag: "--user",
+    wantedBy: "default.target"
+  };
+}
+function isRootUser() {
+  return typeof process.getuid === "function" && process.getuid() === 0;
+}
+
+exports.SERVICE_NAME = SERVICE_NAME;
+exports.isRootUser = isRootUser;
+exports.systemdScopeFor = systemdScopeFor;

package/dist/task-_nr7J19j.cjs

@@ -0,0 +1,167 @@
+'use strict';
+
+var chalk = require('chalk');
+var path = require('node:path');
+var logger = require('./persistence-CBTtC_dm.cjs');
+var sessionList = require('./sessionList-lQ-nqEhc.cjs');
+var sessionSummary = require('./sessionSummary-CcORiQSq.cjs');
+var workflowCommon = require('./workflowCommon-Bl568-rt.cjs');
+require('node:fs/promises');
+require('node:fs');
+require('node:os');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('fs');
+require('axios');
+require('./auth-C7ZScWEw.cjs');
+require('qrcode-terminal');
+require('./time-Bj2HRkKH.cjs');
+require('./browser-DzgO4oaD.cjs');
+require('open');
+require('react');
+require('ink');
+require('./sessionKeyCache-CDmexJ9p.cjs');
+
+function printTaskHelp() {
+  console.log(`
+${chalk.bold("happy task")} - Agent handoff helpers
+
+${chalk.bold("Usage:")}
+  happy task brief --session <sessionId> [options]
+  happy task brief <sessionId> [options]
+  happy task brief --recent [--project <path>] [options]
+
+${chalk.bold("Options:")}
+  --session <id>       Happy session ID to summarize
+  --recent             Pick the most recent session, optionally filtered by --project
+  --project <path>     Project path filter for --recent
+  --limit <n>          Raw messages to compact (default: 200)
+  --max-turns <n>      Compact turns to include (default: 80)
+  --text-limit <n>     Max chars per text block (default: 800)
+  --out <path>         Write the brief to a markdown file
+  --json               Print machine-readable JSON
+  -h, --help           Show this help
+`);
+}
+function collectSessionText(summary) {
+  const chunks = [];
+  if (summary.storedSummary) chunks.push(summary.storedSummary);
+  for (const turn of summary.turns) {
+    if (turn.user?.text) chunks.push(turn.user.text);
+    for (const text of turn.assistantTexts) chunks.push(text.text);
+  }
+  return chunks.join("\n");
+}
+function extractMatchingLines(text, patterns, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.replace(/^[-*]\s*/, "").trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    if (patterns.some((pattern) => pattern.test(trimmed))) {
+      seen.add(trimmed);
+      lines.push(trimmed);
+    }
+    if (lines.length >= limit) break;
+  }
+  return lines;
+}
+function bulletList(lines, fallback) {
+  if (lines.length === 0) return `- ${fallback}`;
+  return lines.map((line) => `- ${line}`).join("\n");
+}
+function buildBriefMarkdown(summary, source) {
+  const text = collectSessionText(summary);
+  const done = extractMatchingLines(text, [/完成|已实现|通过|passed|fixed|implemented|verified/i], 6);
+  const blockers = extractMatchingLines(text, [/失败|阻塞|blocked|failed|error|E401|unrelated/i], 6);
+  const next = extractMatchingLines(text, [/继续|下一步|TODO|todo|next|publish|发布|验证|verify/i], 6);
+  return `# Happy Task Brief
+
+- Source: ${source}
+- Session: \`${summary.sessionId}\`
+- Active: ${summary.active ? "yes" : "no"}
+- Agent: ${summary.agent.name ?? "(unknown)"}${summary.agent.model ? ` / ${summary.agent.model}` : ""}
+- Machine: ${summary.machine.name ?? summary.machine.id ?? "(unknown)"}
+- Path: ${summary.path ?? "(unknown)"}
+- Updated: ${new Date(summary.updatedAt).toISOString()}
+
+## Stored Summary
+
+${summary.storedSummary ?? "(none)"}
+
+## Recent Conversation
+
+${summary.summaryText}
+
+## Done / Evidence
+
+${bulletList(done, "No explicit completion evidence detected in the compact window.")}
+
+## Blockers / Risks
+
+${bulletList(blockers, "No explicit blocker detected in the compact window.")}
+
+## Suggested Next Actions
+
+${bulletList(next, "Continue from the latest user request and verify before reporting completion.")}
+
+## Continuation Prompt
+
+Continue session \`${summary.sessionId}\` from this brief. Preserve existing user changes, inspect the repository rules before editing, implement only the requested scope, run focused verification, and summarize changed files plus test results in Chinese.
+`;
+}
+function findRecentSession(sessions, projectPath) {
+  if (!projectPath) return sessions[0];
+  const resolved = path.resolve(projectPath);
+  return sessions.find((session) => {
+    if (!session.path) return false;
+    const path$1 = path.resolve(session.path);
+    return path$1 === resolved || path$1.startsWith(`${resolved}/`) || resolved.startsWith(`${path$1}/`);
+  });
+}
+async function handleTaskCommand(args) {
+  const action = args[0];
+  if (!action || action === "-h" || action === "--help") {
+    printTaskHelp();
+    return;
+  }
+  if (action !== "brief") {
+    throw new Error(`Unknown task command: ${action}. Use "happy task brief".`);
+  }
+  const parsed = workflowCommon.parseWorkflowArgs(args.slice(1), /* @__PURE__ */ new Set(["--session", "--project", "--limit", "--max-turns", "--text-limit", "--out"]));
+  const credentials = await logger.readCredentials();
+  if (!credentials) {
+    throw new Error('No happy credentials found. Run "happy auth login" first.');
+  }
+  let sessionId = workflowCommon.stringFlag(parsed, "--session") ?? parsed.positionals[0];
+  let source = "session";
+  if (!sessionId && workflowCommon.booleanFlag(parsed, "--recent")) {
+    const result = await sessionList.runSessionList(credentials, { status: "all", limit: 150 });
+    const recent = findRecentSession(result.sessions, workflowCommon.stringFlag(parsed, "--project"));
+    if (!recent) {
+      throw new Error("No matching recent session found.");
+    }
+    sessionId = recent.sessionId;
+    source = "recent";
+  }
+  if (!sessionId) {
+    throw new Error('Session ID required. Use "happy task brief --session <id>" or "--recent".');
+  }
+  const input = {
+    sessionId,
+    limit: workflowCommon.numberFlag(parsed, "--limit"),
+    maxTurns: workflowCommon.numberFlag(parsed, "--max-turns"),
+    textLimit: workflowCommon.numberFlag(parsed, "--text-limit"),
+    includeTools: true
+  };
+  const summary = await sessionSummary.runSessionSummary(credentials, input);
+  const brief = buildBriefMarkdown(summary, source);
+  if (workflowCommon.booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify({ source, summary, brief }, null, 2));
+    return;
+  }
+  await workflowCommon.printOrWriteOutput(brief, workflowCommon.stringFlag(parsed, "--out"));
+}
+
+exports.handleTaskCommand = handleTaskCommand;