@lark-codem/codem-cli 0.1.252 → 0.1.253

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-codem/codem-cli",
-  "version": "0.1.252",
+  "version": "0.1.253",
   "codemServiceManagementProtocol": 3,
   "codemProfileProtocol": 1,
   "type": "module",
@@ -29,17 +29,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@lark-codem/codem-core": "0.8.80",
+    "@lark-codem/codem-core": "0.8.79",
     "zod": "3.25.76",
-    "@lark-codem/lark-cli": "0.1.1-test.20261024.3"
+    "@lark-codem/lark-cli": "0.1.1"
   },
   "optionalDependencies": {
-    "@lark-codem/codem-cli-darwin-arm64": "0.1.252",
-    "@lark-codem/codem-cli-darwin-x64": "0.1.252",
-    "@lark-codem/codem-cli-linux-arm64": "0.1.252",
-    "@lark-codem/codem-cli-linux-x64": "0.1.252",
-    "@lark-codem/codem-cli-win32-arm64": "0.1.252",
-    "@lark-codem/codem-cli-win32-x64": "0.1.252"
+    "@lark-codem/codem-cli-darwin-arm64": "0.1.253",
+    "@lark-codem/codem-cli-darwin-x64": "0.1.253",
+    "@lark-codem/codem-cli-linux-arm64": "0.1.253",
+    "@lark-codem/codem-cli-linux-x64": "0.1.253",
+    "@lark-codem/codem-cli-win32-arm64": "0.1.253",
+    "@lark-codem/codem-cli-win32-x64": "0.1.253"
   },
   "engines": {
     "node": ">=18"

package/profile/credential-errors.js

@@ -30,5 +30,8 @@ export class CredentialStorageError extends Error {
 
 export function isRecoverableCredentialState(error) {
   return error?.code === "credential_storage_rotation_pending"
-    || error?.code === "credential_storage_rotation_unknown";
+    || error?.code === "credential_storage_rotation_unknown"
+    // A missing OAuth record permits reauthorization with the existing device,
+    // never use of its stale plaintext mirror or another credential kind.
+    || (error?.code === "credential_storage_missing" && error.kind === "oauth");
 }

package/profile/runtime-logs.js

@@ -10,7 +10,28 @@ const CAPACITY = 256;
 const BATCH_SIZE = 32;
 const INTERVAL_MS = 10_000;
 const REQUEST_TIMEOUT_MS = 3_000;
+const OBSERVATION_EVENTS = new Set(["command_delivery_observed", "command_admission", "runtime_capability_probe", "command_ack", "command_observation_closed", "diagnostic_reporter_health"]);
+const OBSERVATION_DIMENSIONS = {
+  phase: ["resolve_binary", "build_env", "host_capabilities", "parse_capabilities", "strict_resume", "verify_binding", "prepare", "persist_state", "trusted_device", "request", "validate_response", "apply_response"],
+  reason: ["runtime_unavailable", "runtime_environment_failed", "capability_probe_failed", "runtime_binary_changed", "strict_resume_unsupported", "turn_context_unsupported", "active_run_protocol_mismatch", "trusted_device_blocked", "shutting_down_handoff", "handoff_target_not_active", "duplicate_inflight", "handler_inflight", "prepare_exception_unknown", "capacity", "stopped", "replaced", "scope_changed", "queue_removed", "local_rejected"],
+  command_type: ["agent.run", "agent.steer", "agent.stop", "task.assign", "task.stop", "artifact.relay.read", "artifact.convert_to_lark_resource", "artifact.download", "directory.list", "git.preview", "workflow.preview"],
+  actor_type: ["device", "sandbox"],
+  ack_status: ["accepted", "ignored_duplicate", "rejected"],
+  ack_outcome: ["accepted", "duplicate", "rejected", "conflicting"],
+  readback_scope: ["command", "delivery", "unmatched"],
+  timing_origin: ["observed", "restored_unknown"]
+};
+const OBSERVATION_METRICS = {
+  command_delivery_observed: ["attempt_delta", "suppressed_count"],
+  command_admission: ["attempt_delta", "suppressed_count", "deferred_age_ms", "deferred_duration_ms"],
+  runtime_capability_probe: ["probe_duration_ms"],
+  command_ack: ["attempt_delta", "suppressed_count", "ack_queue_wait_ms", "ack_settle_duration_ms", "pending_ack_age_ms", "pending_command_ack_count", "pending_ack_unknown_age_count"],
+  command_observation_closed: ["omitted_detail_count", "pending_command_ack_count", "deferred_count"],
+  diagnostic_reporter_health: ["dropped_delta", "upload_failure_delta", "pending_event_count"]
+};
+const EXTRA_FIELDS = ["observation_id", "runtime_client_instance_id", "command_id", "delivery_id", "probe_id", "sync_id", "transport_request_id"];
 const STRING_FIELDS = new Set([
+  ...EXTRA_FIELDS, "command_type", "ack_status", "ack_outcome", "readback_scope", "timing_origin", "required_capability",
   "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",
@@ -19,6 +40,7 @@ const STRING_FIELDS = new Set([
   "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([
+  ...new Set(Object.values(OBSERVATION_METRICS).flat()),
   "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",
@@ -40,6 +62,16 @@ function optional(read) {
   try { return read(); } catch { return undefined; }
 }
 
+function metricProjection(event, fields = {}) {
+  return { count: 1, ...Object.fromEntries((OBSERVATION_METRICS[event] ?? [])
+    .filter(key => typeof fields?.[key] === "number" && Number.isFinite(fields[key]) && fields[key] >= 0)
+    .map(key => [key, fields[key]])) };
+}
+
+function extraProjection(fields = {}) {
+  return Object.fromEntries(EXTRA_FIELDS.filter(key => token(fields?.[key])).map(key => [key, token(fields[key])]));
+}
+
 function projectFields(input) {
   const result = {};
   for (const [key, value] of Object.entries(input ?? {}).slice(0, 100)) {
@@ -52,6 +84,8 @@ function projectFields(input) {
     }
   }
   const error = input?.error ?? input?.terminalError;
+  const fingerprint = input?.error_fingerprint ?? input?.errorFingerprint;
+  if (typeof fingerprint === "string" && /^[a-f0-9]{24}$/u.test(fingerprint)) result.error_fingerprint = fingerprint;
   const terminal = input?.terminalError ?? error?.terminalError;
   if (terminal && typeof terminal === "object") {
     if (token(terminal.code)) result.error_code = token(terminal.code);
@@ -90,6 +124,10 @@ export class RuntimeLogReporter {
   #timer;
   #closed = false;
   #dropped = 0;
+  #uploadFailures = 0;
+  #reportedDrops = 0;
+  #reportedFailures = 0;
+  #lastHealthAt = Date.now();
   #send;
   #role;
   #version;
@@ -144,7 +182,7 @@ export class RuntimeLogReporter {
           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 });
+          this.#replay.queue.push({ header: entry.header, record: entry.record, metrics: metricProjection(entry.record.category.event, entry.metrics), extra: extraProjection(entry.extra), attempts: 0, crashFile: file });
         } catch { /* A partial crash write cannot prevent startup. */ }
       }
     } catch { /* First startup or unavailable storage. */ }
@@ -169,12 +207,14 @@ export class RuntimeLogReporter {
 
   get pendingCount() { return this.#live.queue.length + this.#replay.queue.length; }
   get droppedCount() { return this.#dropped; }
+  get identityKey() { return JSON.stringify([this.#instanceId, this.#role, this.#identity.deviceId, this.#identity.userId, this.#identity.tenantId]); }
 
   record(level, component, event, fields = {}) {
     try {
       if (this.#closed) return false;
       let safeFields;
       try { safeFields = projectFields(fields); } catch { safeFields = {}; }
+      if (OBSERVATION_EVENTS.has(event)) safeFields.observation_id = randomUUID();
       const severity = ["info", "warn", "error", "fatal"].includes(level) ? level : "info";
       const identity = { ...this.#identity };
       const category = {
@@ -186,6 +226,11 @@ export class RuntimeLogReporter {
         ...(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]]))
       };
+      if (OBSERVATION_EVENTS.has(category.event)) {
+        for (const [key, values] of Object.entries(OBSERVATION_DIMENSIONS)) {
+          if (safeFields[key]) category[key] = values.includes(safeFields[key]) ? safeFields[key] : "unknown";
+        }
+      }
       const header = {
         aid: SLARDAR_PC_AID,
         device_id: identity.deviceId ?? this.#instanceId,
@@ -207,17 +252,39 @@ export class RuntimeLogReporter {
         log_type: "log", log_level: severity === "fatal" ? "error" : severity,
         log_content: `CodeM diagnostic ${severity} ${category.component}/${category.event}\n${JSON.stringify(payload)}`
       };
+      const priority = severity === "fatal" ? 3 :
+        ["resumed", "settled"].includes(safeFields.stage) || (severity === "error" && !safeFields.suppressed_count) ? 2 :
+        severity === "info" ? 0 : 1;
       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);
+        const minimum = Math.min(...this.#live.queue.map(entry => entry.priority ?? (entry.record.log_level === "info" ? 0 : 1)));
+        if (minimum > priority) { this.#dropped += 1; return false; }
+        const expendable = this.#live.queue.findIndex(entry => (entry.priority ?? (entry.record.log_level === "info" ? 0 : 1)) === minimum);
+        this.#live.queue.splice(expendable, 1);
         this.#dropped += 1;
       }
-      this.#live.queue.push({ header, record, attempts: 0 });
+      this.#live.queue.push({ header, record, metrics: metricProjection(category.event, safeFields), extra: extraProjection(safeFields), priority, attempts: 0 });
       return true;
     } catch { return false; }
   }
 
   async flush({ timeoutMs = REQUEST_TIMEOUT_MS } = {}) {
+    // Counters only in the failure path: never recursively log an upload error.
+    if (Date.now() - this.#lastHealthAt >= 60_000 && (this.#dropped !== this.#reportedDrops || this.#uploadFailures !== this.#reportedFailures)) {
+      this.#lastHealthAt = Date.now();
+      const dropped = this.#dropped;
+      const failures = this.#uploadFailures;
+      const queued = this.record("warn", "runtime-post", "diagnostic_reporter_health", {
+        dropped_delta: dropped - this.#reportedDrops,
+        upload_failure_delta: failures - this.#reportedFailures,
+        pending_event_count: this.pendingCount
+      });
+      // The health record can itself evict an entry or be refused by a full
+      // higher-priority queue. Neither loss has been included in this snapshot.
+      if (queued) {
+        this.#reportedDrops = dropped;
+        this.#reportedFailures = failures;
+      }
+    }
     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
@@ -262,10 +329,10 @@ export class RuntimeLogReporter {
         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, {
+        const data = batch.flatMap(({ record, metrics, extra }) => [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 }
+          log_type: "flexible", event_name: "codem_runtime_diagnostic", category: record.category, metrics: metrics ?? { count: 1 }, ...(extra ? { extra } : {})
         }]);
         try {
           await Promise.race([Promise.resolve().then(() => this.#send({ header: first.header, data }, { signal: controller.signal })), deadline]);
@@ -273,6 +340,7 @@ export class RuntimeLogReporter {
             if (entry.crashFile) { try { fs.unlinkSync(entry.crashFile); } catch { /* Replay may duplicate after a crash or concurrent startup. */ } }
           }
         } catch {
+          this.#uploadFailures += 1;
           // 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) {
@@ -303,6 +371,9 @@ export class RuntimeLogReporter {
 
 let active;
 
+export function runtimeLogsEnabled() { return Boolean(active); }
+export function runtimeLogIdentityKey() { return active?.identityKey; }
+
 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;