@lark-codem/codem-cli 0.1.238-dev-answer.100102807620.0.g6c5c7f5 → 0.1.238-dev.100102827515.0.g871f708

package/profile/runtime-logs.js

@@ -1,374 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import os from "node:os";
-import fs from "node:fs";
-import path from "node:path";
-import { diagnosticId } from "./diagnostic-id.js";
-import { readDeviceId } from "./device-identity.js";
-import { sendSlardarPcBatch, SLARDAR_PC_AID, SLARDAR_PC_REPORTER_VERSION } from "./slardar-pc-transport.js";
-
-const CAPACITY = 256;
-const BATCH_SIZE = 32;
-const INTERVAL_MS = 10_000;
-const REQUEST_TIMEOUT_MS = 3_000;
-const STRING_FIELDS = new Set([
-  "request_id", "command_id", "session_id", "task_id", "dispatch_id", "event_id", "sync_id",
-  "process_instance_id", "run_id", "stage", "phase", "status", "outcome", "reason", "action",
-  "error_class", "error_code", "error_kind", "error_type", "code", "signal", "stop_reason",
-  "terminal_event", "event_type", "actor_type", "source", "trigger", "hook_id", "hook_event",
-  "target_version", "cli_version", "core_version", "version", "previous_state", "state",
-  "failure_kind", "failure_impact", "failure_type", "failure_subtype", "failure_code", "failure_status", "delay_source", "mode", "provider", "name", "termination", "interaction_id", "interaction_kind", "owner_state", "artifact_id", "resource_type", "delivery_mode", "host", "scheme", "tool_call_id", "tool_name", "background_task_id", "model", "artifact_kind", "codem_user_id", "device_id", "operation", "foreground_error_code"
-]);
-const VALUE_FIELDS = new Set([
-  "pid", "exit_code", "duration_ms", "elapsed_ms", "wait_ms", "run_ms", "total_ms", "took_ms",
-  "attempt", "attempts", "attempt_count", "retryable", "http_status", "active_task_count",
-  "pending_event_count", "pending_command_ack_count", "next_retry_ms", "consecutive_failures",
-  "outage_duration_ms", "startup_duration_ms", "failed_attempts", "active_runs", "completed",
-  "delivered", "result_delivered", "queued_behind_existing", "expected", "timed_out",
-  "force_exit_ms", "teardown_ceiling_ms", "recovered", "count", "ms_since_process_start", "owner_pid", "consumed", "delivery_attempt", "ack_deadline_ms", "command_to_bridge_ms", "size_bytes", "before", "after", "omitted_detail_count", "opened", "selected", "foreground"
-]);
-
-function token(value) {
-  return typeof value === "string" && /^[a-z\d._:-]{1,128}$/iu.test(value.trim())
-    ? value.trim() : undefined;
-}
-
-function fieldName(key) {
-  return key.replace(/[A-Z]/gu, (letter) => `_${letter.toLowerCase()}`);
-}
-
-function optional(read) {
-  try { return read(); } catch { return undefined; }
-}
-
-function projectFields(input) {
-  const result = {};
-  for (const [key, value] of Object.entries(input ?? {}).slice(0, 100)) {
-    const name = fieldName(key);
-    if (STRING_FIELDS.has(name)) {
-      const safe = token(value);
-      if (safe) result[name] = safe;
-    } else if (VALUE_FIELDS.has(name) && (typeof value === "boolean" || (typeof value === "number" && Number.isFinite(value)))) {
-      result[name] = value;
-    }
-  }
-  const error = input?.error ?? input?.terminalError;
-  const terminal = input?.terminalError ?? error?.terminalError;
-  if (terminal && typeof terminal === "object") {
-    if (token(terminal.code)) result.error_code = token(terminal.code);
-    if (token(terminal.kind)) result.error_kind = token(terminal.kind);
-  }
-  if (error) {
-    if (typeof error === "object") {
-      if (token(error.name)) result.error_type = token(error.name);
-      if (token(error.code)) result.error_code = token(error.code);
-      if (token(error.kind)) result.error_kind = token(error.kind);
-    }
-    // Errors can contain prompts, paths and raw upstream response bodies.
-    // Retain classification + a fingerprint, never their arbitrary text.
-    const message = typeof error === "string" ? error : error.message;
-    if (typeof message === "string") result.error_fingerprint = createHash("sha256").update(message.slice(0, 4096)).digest("hex").slice(0, 24);
-  }
-  return result;
-}
-
-export function runtimeLogIdentity(config) {
-  const oauth = optional(() => config?.auth?.oauth);
-  return {
-    deviceId: optional(() => token(readDeviceId(config))),
-    // open_id and lastLoginUser are different identities / historical owners.
-    userId: optional(() => token(oauth?.slardarUserId)),
-    tenantId: optional(() => token(oauth?.tenantId ?? oauth?.tenant_id)),
-    channel: optional(() => token(config?.channel)),
-    serverEnvironment: optional(() => typeof config?.serverUrl === "string" && /(?:^|[./-])boe(?:[./-]|$)/iu.test(config.serverUrl) ? "boe" : undefined)
-  };
-}
-
-export class RuntimeLogReporter {
-  #live = { queue: [], inflight: undefined, abort: undefined };
-  #replay = { queue: [], inflight: undefined, abort: undefined };
-  #identity = {};
-  #timer;
-  #closed = false;
-  #dropped = 0;
-  #send;
-  #role;
-  #version;
-  #instanceId;
-  #diagnosticId;
-  #platform;
-  #osVersion;
-  #crashDirectory;
-
-  constructor({ role = "cli", version = "unknown", send = sendSlardarPcBatch, instanceId = randomUUID(), diagnosticId: supportId = diagnosticId(), platform = process.platform, osVersion = os.release(), crashDirectory } = {}) {
-    this.#send = send;
-    this.#crashDirectory = crashDirectory;
-    this.#role = token(role) ?? "cli";
-    this.#version = token(version) ?? "unknown";
-    this.#instanceId = instanceId;
-    this.#diagnosticId = supportId;
-    this.#platform = platform === "win32" ? "Windows" : platform === "darwin" ? "Mac OS X" : platform;
-    this.#osVersion = osVersion;
-    this.#timer = setInterval(() => { void this.flush(); }, INTERVAL_MS);
-    this.#timer.unref?.();
-    this.#restoreCrashes();
-  }
-
-  // Crash files hold already-projected records and the identity at failure time.
-  // Never await network IO in uncaughtExceptionMonitor. Replay is at-least-once.
-  persistCrash(component, event, fields = {}) {
-    try {
-      if (!this.#crashDirectory || this.#closed) return;
-      if (!this.record("fatal", component, event, fields)) return;
-      const entry = this.#live.queue.pop();
-      fs.mkdirSync(this.#crashDirectory, { recursive: true, mode: 0o700 });
-      const names = fs.readdirSync(this.#crashDirectory).filter(name => /^js-[a-f0-9-]+\.json$/u.test(name));
-      if (names.length >= 32) return;
-      fs.writeFileSync(path.join(this.#crashDirectory, `js-${randomUUID()}.json`), JSON.stringify(entry), { flag: "wx", mode: 0o600 });
-    } catch { /* Crash diagnostics must preserve the original exit behavior. */ }
-  }
-
-  #restoreCrashes() {
-    try {
-      for (const name of fs.readdirSync(this.#crashDirectory).filter(name => /^js-[a-f0-9-]+\.json$/u.test(name)).slice(0, 32)) {
-        const file = path.join(this.#crashDirectory, name);
-        try {
-          if (fs.lstatSync(file).isSymbolicLink() || fs.statSync(file).size > 65536) continue;
-          const entry = JSON.parse(fs.readFileSync(file, "utf8"));
-          if (entry?.record?.category?.reporter !== "codem_js" || entry?.record?.log_type !== "log" || !entry.header) continue;
-          this.#replay.queue.push({ header: entry.header, record: entry.record, attempts: 0, crashFile: file });
-        } catch { /* A partial crash write cannot prevent startup. */ }
-      }
-    } catch { /* First startup or unavailable storage. */ }
-  }
-
-  observeConfig(config) {
-    // A sandbox may read the launcher profile for credentials. That profile is
-    // not the tenant/device owning the sandbox's runtime diagnostics.
-    if (this.#role === "sandbox") return;
-    try { this.#identity = runtimeLogIdentity(config); } catch { this.#identity = {}; }
-  }
-
-  observeSandboxConfig(config) {
-    this.#role = "sandbox";
-    this.#identity = {
-      deviceId: optional(() => token(config?.deviceId)),
-      tenantId: optional(() => token(config?.tenantId ?? config?.tenantKey)),
-      serverEnvironment: runtimeLogIdentity(config).serverEnvironment
-    };
-    // ownerUserKey is not a Slardar UID. Keep user_id anonymous in this scope.
-  }
-
-  get pendingCount() { return this.#live.queue.length + this.#replay.queue.length; }
-  get droppedCount() { return this.#dropped; }
-
-  record(level, component, event, fields = {}) {
-    try {
-      if (this.#closed) return false;
-      let safeFields;
-      try { safeFields = projectFields(fields); } catch { safeFields = {}; }
-      const severity = ["info", "warn", "error", "fatal"].includes(level) ? level : "info";
-      const identity = { ...this.#identity };
-      const category = {
-        client_kind: "cli", runtime_role: this.#role, reporter: "codem_js", log_schema: "1",
-        component: token(component) ?? "unknown", event: token(event) ?? "unknown", severity,
-        identity_source: identity.deviceId ? "codem" : "process",
-        diagnostic_id: this.#diagnosticId,
-        ...(identity.tenantId ? { tenant_id: identity.tenantId } : {}),
-        ...(identity.serverEnvironment ? { server_environment: identity.serverEnvironment } : {}),
-        ...Object.fromEntries(["stage", "error_class", "error_code", "error_kind", "outcome"].filter((key) => safeFields[key]).map((key) => [key, safeFields[key]]))
-      };
-      const header = {
-        aid: SLARDAR_PC_AID,
-        device_id: identity.deviceId ?? this.#instanceId,
-        user_id: identity.userId ?? "0",
-        parfait_version: SLARDAR_PC_REPORTER_VERSION,
-        channel: identity.channel ?? "unknown",
-        os: this.#platform, os_version: this.#osVersion
-      };
-      const timestamp = Date.now();
-      const payload = {
-        schema_version: 1, timestamp, component: category.component, event: category.event, level: severity,
-        process_instance_id: this.#instanceId, diagnostic_id: this.#diagnosticId, pid: process.pid,
-        ...(identity.tenantId ? { tenant_id: identity.tenantId } : {}),
-        fields: safeFields
-      };
-      const record = {
-        app_version: this.#version, app_minor_version: "", build_id: "",
-        process_type: `codem-${this.#role}`, session_id: "", timestamp, category,
-        log_type: "log", log_level: severity === "fatal" ? "error" : severity,
-        log_content: `CodeM diagnostic ${severity} ${category.component}/${category.event}\n${JSON.stringify(payload)}`
-      };
-      if (this.#live.queue.length >= CAPACITY) {
-        const expendable = this.#live.queue.findIndex((entry) => entry.record.log_level === "info");
-        this.#live.queue.splice(expendable >= 0 ? expendable : 0, 1);
-        this.#dropped += 1;
-      }
-      this.#live.queue.push({ header, record, attempts: 0 });
-      return true;
-    } catch { return false; }
-  }
-
-  async flush({ timeoutMs = REQUEST_TIMEOUT_MS } = {}) {
-    const deadline = Date.now() + timeoutMs;
-    const live = this.#flushLane(this.#live, timeoutMs).then(() => {
-      // Cover records added after drain's last queue check but before its
-      // promise clears. Deferred retries still wait for the regular timer.
-      const remaining = deadline - Date.now();
-      if (remaining > 0 && this.#live.queue.some(entry => entry.attempts === 0)) {
-        return this.#flushLane(this.#live, remaining);
-      }
-    });
-    // Run both lanes concurrently: old replay cannot delay live sends. Waiting
-    // for both within one budget also gives short-lived invocations a chance
-    // to finish replay; a timeout leaves its original crash file for next time.
-    const replay = this.#flushLane(this.#replay, REQUEST_TIMEOUT_MS);
-    let timer;
-    try {
-      await Promise.race([
-        Promise.all([live, replay]),
-        new Promise(resolve => { timer = setTimeout(resolve, timeoutMs); timer.unref?.(); })
-      ]);
-    } finally { clearTimeout(timer); }
-  }
-
-  #flushLane(lane, timeoutMs) {
-    if (lane.inflight) return lane.inflight;
-    if (this.#closed || lane.queue.length === 0) return Promise.resolve();
-    lane.inflight = this.#drain(lane, timeoutMs).catch(() => {}).finally(() => { lane.inflight = undefined; });
-    return lane.inflight;
-  }
-
-  async #drain(lane, timeoutMs) {
-    const retry = [];
-    const controller = new AbortController();
-    lane.abort = controller;
-    let expire;
-    const deadline = new Promise((_, reject) => {
-      expire = setTimeout(() => { controller.abort(); reject(new Error("Slardar upload timed out")); }, timeoutMs);
-      expire.unref?.();
-    });
-    try {
-      while (lane.queue.length && !this.#closed) {
-        const first = lane.queue[0];
-        const key = JSON.stringify(first.header);
-        const batch = [];
-        while (batch.length < BATCH_SIZE && lane.queue.length && JSON.stringify(lane.queue[0].header) === key && Boolean(lane.queue[0].crashFile) === Boolean(first.crashFile)) batch.push(lane.queue.shift());
-        const data = batch.flatMap(({ record }) => [record, {
-          app_version: record.app_version, app_minor_version: "", build_id: "",
-          process_type: record.process_type, session_id: "", timestamp: record.timestamp,
-          log_type: "flexible", event_name: "codem_runtime_diagnostic", category: record.category, metrics: { count: 1 }
-        }]);
-        try {
-          await Promise.race([Promise.resolve().then(() => this.#send({ header: first.header, data }, { signal: controller.signal })), deadline]);
-          for (const entry of batch) {
-            if (entry.crashFile) { try { fs.unlinkSync(entry.crashFile); } catch { /* Replay may duplicate after a crash or concurrent startup. */ } }
-          }
-        } catch {
-          // One later retry, on the regular interval. Bound both memory and work;
-          // an unavailable collector must not create a retry loop or block exit.
-          for (const entry of batch) {
-            if (!this.#closed && entry.attempts === 0 && retry.length + lane.queue.length < CAPACITY) {
-              entry.attempts += 1;
-              retry.push(entry);
-            } else this.#dropped += 1;
-          }
-          if (controller.signal.aborted) break;
-        }
-      }
-    } finally {
-      if (!this.#closed) lane.queue.push(...retry.slice(0, Math.max(0, CAPACITY - lane.queue.length)));
-      clearTimeout(expire);
-      lane.abort = undefined;
-    }
-  }
-
-  close() {
-    this.#closed = true;
-    clearInterval(this.#timer);
-    for (const lane of [this.#live, this.#replay]) {
-      lane.abort?.abort();
-      lane.queue.length = 0;
-    }
-  }
-}
-
-let active;
-
-export function startRuntimeLogs({ role, version, env = process.env, send } = {}) {
-  try {
-    if (active || /^(1|true|yes)$/iu.test(env.CODEM_TELEMETRY_DISABLED ?? "") || env.NODE_TEST_CONTEXT) return;
-    const root = env.CODEM_HOME || env.LINCO_HOME || path.join(os.homedir(), ".codem");
-    active = new RuntimeLogReporter({ role, version, send, crashDirectory: path.join(root, "runtime-crashes") });
-  } catch { /* Monitoring initialization never prevents a command from running. */ }
-}
-
-export function observeRuntimeLogConfig(config) {
-  try { active?.observeConfig(config); } catch { /* best effort */ }
-}
-
-export function observeRuntimeLogSandboxConfig(config) {
-  try { active?.observeSandboxConfig(config); } catch { /* best effort */ }
-}
-
-export function recordRuntimeLog(level, component, event, fields = {}) {
-  try { return active?.record(level, component, event, fields) ?? false; } catch { return false; }
-}
-
-export function persistRuntimeCrash(component, event, fields) {
-  try { active?.persistCrash(component, event, fields); } catch { /* best effort */ }
-}
-
-export async function flushRuntimeLogs(budgetMs = 200) {
-  if (!active) return;
-  let timeout;
-  try {
-    await Promise.race([
-      active.flush({ timeoutMs: budgetMs }),
-      new Promise((resolve) => { timeout = setTimeout(resolve, budgetMs); })
-    ]);
-  } catch { /* best effort, including a broken uploader */ } finally { clearTimeout(timeout); }
-}
-
-// Existing debug sites contain both useful operational events and user data.
-// Observe the client's final payload; this does not assert server delivery.
-export function recordPreparedArtifacts(component, artifacts, context = {}) {
-  try {
-    const limit = 32;
-    recordRuntimeLog("info", component, "artifact.delivery_prepared", { ...context, count: artifacts.length, omitted_detail_count: Math.max(0, artifacts.length - limit) });
-    for (const artifact of artifacts.slice(0, limit)) {
-      const file = artifact?.file;
-      const uri = artifact?.url?.uri ?? file?._downloadUrl ?? artifact?.image?.uri;
-      let urlFields = {};
-      try {
-        const parsed = new URL(uri);
-        urlFields = { host: parsed.hostname, scheme: parsed.protocol.replace(/:$/u, "") };
-      } catch { /* Local references have no remote URL. */ }
-      const route = file?._localArtifactRef ? "local_relay"
-        : file?._artifactId || artifact?._imgKey ? "uploaded"
-        : file?._data || artifact?.image?._data ? "inline"
-        : artifact?.kind === "url" || urlFields.host ? "url" : "reference";
-      recordRuntimeLog("info", component, "artifact.delivery_item", {
-        ...context, artifact_kind: artifact?.kind, delivery_mode: route,
-        artifact_id: file?._artifactId ?? file?._localArtifactRef ?? artifact?._imgKey,
-        ...urlFields
-      });
-    }
-  } catch { /* Diagnostics cannot interrupt delivery. */ }
-}
-
-export function recordInteractiveProcessExit({ exitCode, signal }) {
-  const abnormalSignal = signal && signal !== "SIGINT" && signal !== "SIGTERM";
-  const failed = abnormalSignal || (exitCode && exitCode !== 130);
-  recordRuntimeLog(failed ? "error" : "info", "cli", "process.exited", { exitCode, signal });
-}
-
-// Select events explicitly, then project fields again at the remote boundary.
-export function recordSelectedRuntimeLog(component, event, fields = {}) {
-  try {
-    const selectedEvent = event.replace(/^linco\./u, "");
-    if (!/^(?:startup\.(?:main|update_check|daemon_service_reconcile|login_gate|login_handoff_to_linco)|oauth\.refresh\.(?:relogin_suspect|persist_failed|persisted)|managed_config\.(?:member_refresh_failed|sandbox_refresh_failed|sandbox_fetch_recovered|sandbox_fetch_exhausted|refreshed|resource_failed)|(?:agent|command)\.(?:start|interactive_start|success|error|spawn_error|resolve_error|exit_drain_timeout|cancelled_before_spawn|artifact_oversize|artifact_missing|artifact_dropped|artifact_route_selected|artifact_image_upload|artifact_file_upload|artifact_local_register)|router\.credentials\.(?:ensured|refresh_failed)|binary\.heal_chmod_failed|project\.(?:inject_error|state)|(?:permission_ask|user_question|plan)\.report_failed|process_tree\.(?:force_kill|force_kill_failed)|artifact\.(?:oversize|missing|dropped)|runtime_post\.daemon\.device_rebind_[a-z_]+)$/u.test(selectedEvent)) return;
-    const expected = optional(() => fields?.errorKind === "user_stop" || fields?.terminalError?.kind === "user_stop" || fields?.exitCode === 130 || fields?.signal === "SIGINT");
-    const level = expected ? "info" : (fields?.status === "failed" || /(?:failed|error|exhausted|timeout)$/u.test(event)) ? "error" : /(?:suspect|dropped|missing|oversize)$/u.test(event) ? "warn" : "info";
-    recordRuntimeLog(level, component, event, fields);
-  } catch { /* best effort */ }
-}

package/profile/slardar-pc-transport.js

@@ -1,38 +0,0 @@
-import https from "node:https";
-import { gzipSync } from "node:zlib";
-
-// PC Custom Log / Custom Event wire format, verified against Parfait 1.7.0.0's
-// public IUploader callback. This is not the Slardar Web/BID protocol. Keep the
-// SDK capture fixture and the platform readback procedure with this adapter.
-export const SLARDAR_PC_AID = "1880";
-// Use the native envelope's four-part version convention in this legacy field.
-// This is our JS adapter version; reporter=codem_js distinguishes it
-// from the native Parfait SDK. Do not advertise a native SDK we do not run.
-export const SLARDAR_PC_REPORTER_VERSION = "1.0.0.0";
-const ENDPOINT = `https://pc-mon.zijieapi.com/monitor_pc/collect/api/pc_log?aid=${SLARDAR_PC_AID}`;
-
-export function sendSlardarPcBatch(payload, { signal, request = https.request } = {}) {
-  return new Promise((resolve, reject) => {
-    const body = gzipSync(Buffer.from(JSON.stringify(payload)));
-    const req = request(ENDPOINT, {
-      method: "POST",
-      signal,
-      headers: {
-        "content-type": "application/json",
-        "content-encoding": "gzip",
-        "content-length": body.length
-      }
-    }, (res) => {
-      // The collector returns an empty 204. Never buffer arbitrary responses.
-      res.resume();
-      res.once("error", reject);
-      res.once("end", () => {
-        if (res.statusCode >= 200 && res.statusCode < 300) resolve();
-        else reject(new Error(`Slardar PC HTTP ${res.statusCode}`));
-      });
-    });
-    req.on("socket", (socket) => socket.unref?.());
-    req.once("error", reject);
-    req.end(body);
-  });
-}