@lark-codem/codem-cli 0.1.267 → 0.1.269-meego-ai-integration.100103555663.0.gda51474

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-codem/codem-cli",
-  "version": "0.1.267",
+  "version": "0.1.269-meego-ai-integration.100103555663.0.gda51474",
   "codemServiceManagementProtocol": 3,
   "codemProfileProtocol": 1,
   "type": "module",
@@ -29,17 +29,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@lark-codem/codem-core": "0.8.85",
-    "zod": "3.25.76",
-    "@lark-codem/lark-cli": "0.1.1"
+    "@lark-codem/codem-core": "0.8.86-meego-ai-integration.100103555251.0.g9fb420c",
+    "zod": "3.25.76"
   },
   "optionalDependencies": {
-    "@lark-codem/codem-cli-darwin-arm64": "0.1.267",
-    "@lark-codem/codem-cli-darwin-x64": "0.1.267",
-    "@lark-codem/codem-cli-linux-arm64": "0.1.267",
-    "@lark-codem/codem-cli-linux-x64": "0.1.267",
-    "@lark-codem/codem-cli-win32-arm64": "0.1.267",
-    "@lark-codem/codem-cli-win32-x64": "0.1.267"
+    "@lark-codem/codem-cli-darwin-arm64": "0.1.269-meego-ai-integration.100103555663.0.gda51474",
+    "@lark-codem/codem-cli-darwin-x64": "0.1.269-meego-ai-integration.100103555663.0.gda51474",
+    "@lark-codem/codem-cli-linux-arm64": "0.1.269-meego-ai-integration.100103555663.0.gda51474",
+    "@lark-codem/codem-cli-linux-x64": "0.1.269-meego-ai-integration.100103555663.0.gda51474",
+    "@lark-codem/codem-cli-win32-arm64": "0.1.269-meego-ai-integration.100103555663.0.gda51474",
+    "@lark-codem/codem-cli-win32-x64": "0.1.269-meego-ai-integration.100103555663.0.gda51474"
   },
   "engines": {
     "node": ">=18"

package/profile/credential-errors.js

@@ -30,8 +30,5 @@ export class CredentialStorageError extends Error {
 
 export function isRecoverableCredentialState(error) {
   return error?.code === "credential_storage_rotation_pending"
-    || 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");
+    || error?.code === "credential_storage_rotation_unknown";
 }

package/profile/runtime-logs.js

@@ -10,59 +10,21 @@ const CAPACITY = 256;
 const BATCH_SIZE = 32;
 const INTERVAL_MS = 10_000;
 const REQUEST_TIMEOUT_MS = 3_000;
-const TRUSTED_DEVICE_EVENTS = new Set(["host_identity_collection", "host_identity_command", "host_session_attempt", "host_session_expired", "trusted_device_admission_blocked", "trusted_device_admission_recovered"]);
-const TRUSTED_DEVICE_PHASES = ["auth", "identity", "provider", "host_key", "activation_state", "activation_apply", "activation_sign", "activation_complete", "credential_resolve", "session_apply", "session_sign", "session_complete", "trusted_device"];
-const TRUSTED_DEVICE_DIMENSIONS = {
-  phase: TRUSTED_DEVICE_PHASES,
-  operation: ["create", "renew", "recovery", "platform_identity", "network_interfaces", "network_ports"],
-  outcome: ["success", "partial", "failed", "ready", "not_registered", "no_auth", "reset", "blocked", "invalid", "verified", "not_required", "absent", "expired"],
-  failure_kind: ["none", "timeout", "exec_failed", "invalid_json", "empty_identity", "read_failed", "authorization", "unknown"]
-};
-const OBSERVATION_EVENTS = new Set(["command_delivery_observed", "command_admission", "runtime_capability_probe", "command_ack", "command_observation_closed", "diagnostic_reporter_health", ...TRUSTED_DEVICE_EVENTS]);
-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 = {
-  host_identity_collection: ["duration_ms", "field_error_count"],
-  host_identity_command: ["duration_ms", "timeout_ms"],
-  host_session_attempt: ["elapsed_ms", "next_retry_ms", "consecutive_failures", "session_remaining_ms", ...TRUSTED_DEVICE_PHASES.map(phase => `${phase}_duration_ms`)],
-  host_session_expired: ["expired_for_ms", "consecutive_failures", "next_retry_ms"],
-  trusted_device_admission_blocked: ["elapsed_ms", "blocked_response_count"],
-  trusted_device_admission_recovered: ["elapsed_ms", "blocked_response_count"],
-  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", "attempt_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",
   "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",
-  "operation_id", "entrypoint"
+  "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([
-  "session_retained",
-  ...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",
   "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", "source_size_bytes", "processed_bytes", "before", "after", "omitted_detail_count", "opened", "selected", "foreground"
+  "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) {
@@ -78,16 +40,6 @@ 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)) {
@@ -100,8 +52,6 @@ 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);
@@ -140,10 +90,6 @@ export class RuntimeLogReporter {
   #timer;
   #closed = false;
   #dropped = 0;
-  #uploadFailures = 0;
-  #reportedDrops = 0;
-  #reportedFailures = 0;
-  #lastHealthAt = Date.now();
   #send;
   #role;
   #version;
@@ -198,7 +144,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, metrics: metricProjection(entry.record.category.event, entry.metrics), extra: extraProjection(entry.extra), attempts: 0, crashFile: file });
+          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. */ }
@@ -223,14 +169,12 @@ 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 = {
@@ -242,14 +186,6 @@ 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)) {
-        const trustedDevice = TRUSTED_DEVICE_EVENTS.has(category.event);
-        // Keep arbitrary upstream error codes in logs, not metric dimensions.
-        if (trustedDevice) for (const key of ["stage", "error_class", "error_code", "error_kind", "outcome"]) delete category[key];
-        for (const [key, values] of Object.entries(trustedDevice ? TRUSTED_DEVICE_DIMENSIONS : 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,
@@ -271,39 +207,17 @@ 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 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);
+        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, metrics: metricProjection(category.event, safeFields), extra: extraProjection(safeFields), priority, attempts: 0 });
+      this.#live.queue.push({ header, record, 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
@@ -348,10 +262,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, metrics, extra }) => [record, {
+        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: metrics ?? { count: 1 }, ...(extra ? { extra } : {})
+          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]);
@@ -359,7 +273,6 @@ 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) {
@@ -390,9 +303,6 @@ 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;