ccem 2.28.0 → 2.30.0

package/dist/index.js

@@ -2702,16 +2702,70 @@ var config = new Conf({
   cwd: getCcemConfigDir()
   // 使用统一的配置目录
 });
-var decryptWithSecret = (encryptedBase64, secret) => {
-  const key = crypto3.scryptSync(secret, "ccem-salt", 32);
+var REMOTE_CRYPTO_ALGORITHM_V2 = "aes-256-gcm";
+var REMOTE_CRYPTO_ALGORITHM_V1 = "aes-256-cbc";
+var isEnvelopeV2 = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return v.v === 2 && typeof v.nonce === "string" && typeof v.ciphertext === "string" && typeof v.tag === "string";
+};
+var deriveRemoteKey = (secret) => crypto3.scryptSync(secret, "ccem-salt", 32);
+var decryptV2Envelope = (envelope, key) => {
+  const nonce = Buffer.from(envelope.nonce, "base64");
+  const ciphertext = Buffer.from(envelope.ciphertext, "base64");
+  const tag = Buffer.from(envelope.tag, "base64");
+  if (nonce.length === 0 || ciphertext.length === 0 || tag.length === 0) {
+    throw new Error("v2 envelope has empty nonce/ciphertext/tag");
+  }
+  const decipher = crypto3.createDecipheriv(
+    REMOTE_CRYPTO_ALGORITHM_V2,
+    key,
+    nonce
+  );
+  decipher.setAuthTag(tag);
+  let decrypted = decipher.update(ciphertext);
+  decrypted = Buffer.concat([decrypted, decipher.final()]);
+  return decrypted.toString("utf8");
+};
+var decryptV1Legacy = (encryptedBase64, key) => {
   const combined = Buffer.from(encryptedBase64, "base64");
+  if (combined.length < 16) {
+    throw new Error("v1 payload too short");
+  }
   const iv = combined.subarray(0, 16);
   const encryptedHex = combined.subarray(16).toString("hex");
-  const decipher = crypto3.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = crypto3.createDecipheriv(REMOTE_CRYPTO_ALGORITHM_V1, key, iv);
   let decrypted = decipher.update(encryptedHex, "hex", "utf8");
   decrypted += decipher.final("utf8");
   return decrypted;
 };
+var decryptWithSecret = (encryptedBase64, secret) => {
+  const key = deriveRemoteKey(secret);
+  let parsedObj = null;
+  try {
+    const jsonStr = Buffer.from(encryptedBase64, "base64").toString("utf8");
+    parsedObj = JSON.parse(jsonStr);
+  } catch {
+  }
+  let envelopeV2 = null;
+  if (parsedObj !== null) {
+    if (isEnvelopeV2(parsedObj)) {
+      envelopeV2 = parsedObj;
+    } else if (parsedObj && typeof parsedObj === "object" && "v" in parsedObj) {
+      const version = parsedObj.v;
+      if (version === 2) {
+        throw new Error(
+          "Malformed v2 envelope: missing required fields (nonce, ciphertext, tag)"
+        );
+      }
+      throw new Error(`Unsupported remote envelope version: ${version}`);
+    }
+  }
+  if (envelopeV2) {
+    return decryptV2Envelope(envelopeV2, key);
+  }
+  return decryptV1Legacy(encryptedBase64, key);
+};
 var getUniqueName = (baseName, existingNames) => {
   if (!existingNames.has(baseName)) {
     return baseName;
@@ -3168,8 +3222,132 @@ function formatCronTaskTableRows(tasks) {
 // src/desktopControl.ts
 import fs10 from "fs";
 import path8 from "path";
+var DEFAULT_REQUEST_TIMEOUT_MS = 5e3;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
+var ENDPOINT_UNREACHABLE_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENOTCONN",
+  "EHOSTUNREACH",
+  "ECONNABORTED"
+]);
+var StaleDesktopControlDescriptorError = class extends Error {
+  name = "StaleDesktopControlDescriptorError";
+  reason;
+  descriptorPath;
+  pid;
+  cleanedUp;
+  cause;
+  constructor(details) {
+    const subject = details.pid !== null ? `process ${details.pid}` : "the publishing process";
+    const symptom = details.reason === "dead-pid" ? `${subject} is no longer running` : details.reason === "endpoint-unreachable" ? "the control endpoint refused the connection" : `the control request timed out after ${details.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS}ms`;
+    const remedy = details.cleanedUp ? "The stale descriptor was removed automatically; start CCEM Desktop and rerun the command." : details.pid !== null ? "Restart CCEM Desktop so it republishes a fresh control endpoint." : "Restart CCEM Desktop to refresh the descriptor, or remove the stale file manually if it is no longer managed.";
+    super(
+      `CCEM Desktop control descriptor at ${details.descriptorPath} is stale: ${symptom}. ${remedy}`
+    );
+    this.reason = details.reason;
+    this.descriptorPath = details.descriptorPath;
+    this.pid = details.pid;
+    this.cleanedUp = details.cleanedUp;
+    if (details.cause !== void 0) {
+      this.cause = details.cause;
+    }
+  }
+};
 function getDesktopControlDescriptorPath() {
-  return process.env.CCEM_CONTROL_FILE?.trim() || path8.join(getCcemConfigDir(), "control.json");
+  return process.env.CCEM_CONTROL_FILE?.trim() || getDefaultControlDescriptorPath();
+}
+function getDefaultControlDescriptorPath() {
+  return path8.join(getCcemConfigDir(), "control.json");
+}
+function isDefaultDescriptorPath(descriptorPath) {
+  try {
+    return path8.resolve(descriptorPath) === path8.resolve(getDefaultControlDescriptorPath());
+  } catch {
+    return false;
+  }
+}
+function safeRemoveStaleDescriptor(descriptorPath) {
+  if (!isDefaultDescriptorPath(descriptorPath)) {
+    return false;
+  }
+  try {
+    fs10.rmSync(descriptorPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readErrnoCode(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const candidate = error;
+  return candidate.code ?? candidate.cause?.code;
+}
+function readPid(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function isLoopbackHost(host) {
+  const normalized = host.trim().toLowerCase().replace(/^\[|\]$/g, "");
+  if (LOOPBACK_HOSTS.has(normalized)) {
+    return true;
+  }
+  if (/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(normalized)) {
+    return true;
+  }
+  if (normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") {
+    return true;
+  }
+  return false;
+}
+function extractHost(endpoint) {
+  const withoutScheme = endpoint.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//, "");
+  const hostPort = withoutScheme.split(/[\/?#]/)[0] || "";
+  if (hostPort.startsWith("[")) {
+    const end = hostPort.indexOf("]");
+    if (end === -1) return null;
+    return hostPort.slice(1, end);
+  }
+  const colonIndex = hostPort.lastIndexOf(":");
+  if (colonIndex === -1) return hostPort;
+  return hostPort.slice(0, colonIndex);
+}
+function validateLoopbackEndpoint(endpoint) {
+  const host = extractHost(endpoint);
+  if (!host) {
+    throw new Error(
+      `CCEM Desktop control endpoint '${redactEndpoint(endpoint)}' is missing a host. Refusing to continue.`
+    );
+  }
+  if (!isLoopbackHost(host)) {
+    throw new Error(
+      `CCEM Desktop control endpoint '${redactEndpoint(endpoint)}' is not bound to loopback. Only 127.0.0.1, localhost, or ::1 are allowed.`
+    );
+  }
+}
+function isPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ESRCH") return false;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+function redactEndpoint(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    return `${url.protocol}//${url.host}${url.pathname}`;
+  } catch {
+    return "<invalid endpoint>";
+  }
+}
+function isDescriptor(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.endpoint === "string" && typeof value.token === "string"
+  );
 }
 function resolveDesktopControlDescriptor(descriptorPath = getDesktopControlDescriptorPath()) {
   if (!fs10.existsSync(descriptorPath)) {
@@ -3181,27 +3359,93 @@ function resolveDesktopControlDescriptor(descriptorPath = getDesktopControlDescr
   if (!endpoint || !token) {
     throw new Error(`Invalid CCEM Desktop control descriptor at ${descriptorPath}`);
   }
-  return {
-    endpoint,
-    token,
-    pid: typeof parsed.pid === "number" ? parsed.pid : null
-  };
+  validateLoopbackEndpoint(endpoint);
+  const pid = readPid(parsed.pid);
+  if (pid !== null && !isPidAlive(pid)) {
+    const cleanedUp = safeRemoveStaleDescriptor(descriptorPath);
+    throw new StaleDesktopControlDescriptorError({
+      reason: "dead-pid",
+      descriptorPath,
+      pid,
+      cleanedUp
+    });
+  }
+  return { endpoint, token, pid };
 }
-async function requestDesktopControl(method, params, descriptor = resolveDesktopControlDescriptor()) {
+async function requestDesktopControl(method, params, descriptorOrOptions, maybeOptions = {}) {
+  const descriptorPath = getDesktopControlDescriptorPath();
+  const hasInjectedDescriptor = isDescriptor(descriptorOrOptions);
+  const descriptor = hasInjectedDescriptor ? descriptorOrOptions : resolveDesktopControlDescriptor(descriptorPath);
+  const options = hasInjectedDescriptor ? maybeOptions : descriptorOrOptions ?? maybeOptions ?? {};
+  const timeoutMs = options.timeoutMs ?? options.fetchTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const pid = readPid(descriptor.pid);
+  validateLoopbackEndpoint(descriptor.endpoint);
+  if (pid !== null && !isPidAlive(pid)) {
+    const cleanedUp = hasInjectedDescriptor ? false : safeRemoveStaleDescriptor(descriptorPath);
+    throw new StaleDesktopControlDescriptorError({
+      reason: "dead-pid",
+      descriptorPath,
+      pid,
+      cleanedUp
+    });
+  }
   const id = `ccem-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const response = await fetch(descriptor.endpoint, {
-    method: "POST",
-    headers: {
-      authorization: `Bearer ${descriptor.token}`,
-      "content-type": "application/json"
-    },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id,
-      method,
-      params: params ?? {}
-    })
-  });
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const externalSignal = options.signal;
+  const onExternalAbort = () => controller.abort();
+  if (externalSignal) {
+    if (externalSignal.aborted) {
+      clearTimeout(timer);
+      controller.abort();
+    } else {
+      externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+    }
+  }
+  let response;
+  try {
+    response = await fetch(descriptor.endpoint, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${descriptor.token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params: params ?? {}
+      }),
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (controller.signal.aborted) {
+      throw new StaleDesktopControlDescriptorError({
+        reason: "request-timeout",
+        descriptorPath,
+        pid,
+        cleanedUp: false,
+        timeoutMs,
+        cause: error
+      });
+    }
+    const code = readErrnoCode(error);
+    if (code && ENDPOINT_UNREACHABLE_CODES.has(code)) {
+      throw new StaleDesktopControlDescriptorError({
+        reason: "endpoint-unreachable",
+        descriptorPath,
+        pid,
+        cleanedUp: false,
+        cause: error
+      });
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    if (externalSignal) {
+      externalSignal.removeEventListener("abort", onExternalAbort);
+    }
+  }
   if (!response.ok) {
     throw new Error(`CCEM Desktop control request failed: HTTP ${response.status}`);
   }
@@ -3211,6 +3455,26 @@ async function requestDesktopControl(method, params, descriptor = resolveDesktop
   }
   return payload.result;
 }
+function parseSinceOption(raw) {
+  if (raw === void 0 || raw === null || raw === "") return null;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value)) {
+    throw new Error(
+      `Invalid --since value '${raw}'. Expected a non-negative integer sequence number (e.g. 0, 42).`
+    );
+  }
+  return value;
+}
+function parseLimitOption(raw) {
+  if (raw === void 0 || raw === null || raw === "") return null;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0 || !Number.isInteger(value)) {
+    throw new Error(
+      `Invalid --limit value '${raw}'. Expected a positive integer (e.g. 1, 100).`
+    );
+  }
+  return value;
+}
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
@@ -4192,10 +4456,12 @@ desktopCmd.command("status <runtimeId>").description("Get one CCEM Desktop works
 });
 desktopCmd.command("events <runtimeId>").description("Read CCEM Desktop workspace session events").option("--since <seq>", "First event sequence after this value").option("--limit <count>", "Maximum events to return").option("--json", "Output JSON").action(async function(runtimeId) {
   const opts = this.opts();
+  const sinceSeq = parseSinceOption(opts.since);
+  const limit = parseLimitOption(opts.limit);
   const result = await requestDesktopControl("ccem.workspace.getEvents", {
     runtimeId,
-    sinceSeq: opts.since ? Number(opts.since) : null,
-    limit: opts.limit ? Number(opts.limit) : null
+    sinceSeq,
+    limit
   });
   outputDesktopResult(result, opts);
 });
@@ -4420,4 +4686,16 @@ Editing environment '${result.name}'`));
     }
   }
 });
-program.parse(process.argv);
+function handleCliError(error) {
+  if (error instanceof StaleDesktopControlDescriptorError) {
+    console.error(chalk7.red(error.message));
+    process.exit(1);
+  }
+  if (error instanceof Error) {
+    console.error(chalk7.red(error.message));
+    process.exit(1);
+  }
+  console.error(chalk7.red(String(error)));
+  process.exit(1);
+}
+await program.parseAsync(process.argv).catch(handleCliError);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccem",
-  "version": "2.28.0",
+  "version": "2.30.0",
   "type": "module",
   "description": "Claude Code Environment Manager",
   "repository": {