@kontextmind/kxm 0.7.14 → 0.7.16

package/plugins/kxm/src/providers/antigravity/utils/http.ts

@@ -0,0 +1,32 @@
+// @ts-nocheck — vendored snapshot; host tsconfig is stricter than upstream.
+import { antigravityEnv } from "./util.ts";
+
+const PREWARM_TIMEOUT_MS = 5_000;
+
+/** Host fetch. Node 22+ already pools connections; no extra HTTP client dep. */
+export async function antigravityFetch(
+  input: string | URL,
+  init: RequestInit = {},
+): Promise<Response> {
+  return fetch(input, init);
+}
+
+/**
+ * Open the TLS connection when the extension loads so the first message of a session
+ * does not pay the handshake either. Best-effort: failures are ignored.
+ */
+export function prewarmConnection(url: string): void {
+  if (antigravityEnv("NO_PREWARM") === "1") return;
+  if (process.env.NODE_TEST_CONTEXT) return;
+  void (async () => {
+    try {
+      const res = await antigravityFetch(url, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(PREWARM_TIMEOUT_MS),
+      });
+      await res.arrayBuffer();
+    } catch {
+      // Warm-up only; the real request will establish the connection instead.
+    }
+  })();
+}

package/plugins/kxm/src/providers/antigravity/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./util.ts";
+export * from "./security.ts";
+export * from "./http.ts";

package/plugins/kxm/src/providers/antigravity/utils/security.ts

@@ -0,0 +1,75 @@
+// @ts-nocheck — vendored snapshot; host tsconfig is stricter than upstream.
+import { antigravityEnv } from "./util.ts";
+
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "::1", "localhost"]);
+const ALLOWED_API_HOST_SUFFIXES = [".googleapis.com", ".sandbox.googleapis.com"];
+
+/** Only loopback binds are allowed so OAuth codes cannot be stolen off-machine. */
+export function resolveCallbackHost(raw = antigravityEnv("CALLBACK_HOST")): string {
+  const host = (raw || "127.0.0.1").trim().toLowerCase();
+  if (!LOOPBACK_HOSTS.has(host)) {
+    throw new Error(
+      `Unsafe ANTIGRAVITY_CALLBACK_HOST="${host}". Only loopback hosts are allowed: 127.0.0.1, ::1, localhost.`,
+    );
+  }
+  return host === "localhost" ? "127.0.0.1" : host;
+}
+
+/** Prevent token exfiltration via poisoned BASE_URL (SSRF / credential leak). */
+export function assertSafeApiBaseUrl(raw: string): string {
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`Invalid ANTIGRAVITY_BASE_URL: ${raw}`);
+  }
+  if (url.protocol !== "https:") {
+    throw new Error(`ANTIGRAVITY_BASE_URL must use https (got ${url.protocol})`);
+  }
+  if (url.username || url.password) {
+    throw new Error("ANTIGRAVITY_BASE_URL must not include credentials");
+  }
+  const host = url.hostname.toLowerCase();
+  const allowed =
+    host === "googleapis.com" || ALLOWED_API_HOST_SUFFIXES.some((suffix) => host.endsWith(suffix));
+  if (!allowed) {
+    throw new Error(
+      `ANTIGRAVITY_BASE_URL host "${host}" is not allowed. Use a *.googleapis.com endpoint.`,
+    );
+  }
+  const path = url.pathname.replace(/\/+$/, "");
+  return `${url.origin}${path === "/" ? "" : path}`;
+}
+
+/** Redact bearer tokens, refresh tokens, and similar secrets from diagnostics/errors. */
+export function redactSecrets(text: string): string {
+  return text
+    .replace(/\bya29\.[A-Za-z0-9._~+/-]+=*/g, "[redacted-access-token]")
+    .replace(/\b1\/\/[A-Za-z0-9_-]+/g, "[redacted-refresh-token]")
+    .replace(/\b1\/[A-Za-z0-9_-]{20,}/g, "[redacted-refresh-token]")
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [redacted]")
+    .replace(
+      /("?(?:access_token|refresh_token|id_token|token|client_secret|code_verifier|authorization)"?\s*[:=]\s*")[^"]*(")/gi,
+      "$1[redacted]$2",
+    )
+    .replace(
+      /("?(?:access_token|refresh_token|id_token|token|client_secret|code_verifier|authorization)"?\s*[:=]\s*)[^\s&,}]+/gi,
+      "$1[redacted]",
+    );
+}
+
+export function maskEmail(email: string | undefined): string | undefined {
+  if (!email || typeof email !== "string") return undefined;
+  const parts = email.split("@");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) return "[redacted-email]";
+  const name = parts[0];
+  const domain = parts[1];
+  const lastChar = name.at(-1) || "";
+  const maskedName = name.length > 2 ? `${name[0]}***${lastChar}` : `${name[0]}***`;
+  return `${maskedName}@${domain}`;
+}
+
+export function safeError(error: unknown): string {
+  const raw = error instanceof Error ? error.message : String(error);
+  return redactSecrets(raw);
+}

package/plugins/kxm/src/providers/antigravity/utils/util.ts

@@ -0,0 +1,133 @@
+// @ts-nocheck — vendored snapshot; host tsconfig is stricter than upstream.
+import { createHash } from "node:crypto";
+import { getModelEnum } from "../models/models.ts";
+
+export function antigravityEnv(name: string): string | undefined {
+  return process.env[`ANTIGRAVITY_${name}`] || process.env[`NOAGY_${name}`];
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value ? value : undefined;
+}
+
+export function sanitizeText(text: unknown): string {
+  return String(text ?? "").replace(/[\uD800-\uDFFF]/g, "\uFFFD");
+}
+
+export function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+export function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function nowRequestId(): string {
+  return antigravityRequestEnvelope("unknown", false).requestId;
+}
+
+/** Deterministic RFC 4122 v5 UUID from seed (survives restarts for the same session seed). */
+export function stableUuid(seed: string): string {
+  const bytes = createHash("sha1").update(seed).digest().subarray(0, 16);
+  bytes[6] = (bytes[6] & 0x0f) | 0x50;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+export type AntigravityEnvelopeOptions = {
+  isClaude?: boolean;
+  isNonGemini?: boolean;
+  step?: number;
+  lastStepIndex?: string;
+  requestIndex?: number;
+  userTurnIndex?: number;
+  trajectoryId?: string;
+  conversationId?: string;
+};
+
+const sessionTrajectoryMap = new Map<string, { conversationId: string; trajectoryId: string }>();
+
+/** Stable conversationId and trajectoryId within a multi-turn conversation session. */
+export function resolveSessionTrajectory(context?: {
+  messages?: Array<{ role?: string; timestamp?: number; content?: unknown }>;
+}): { conversationId: string; trajectoryId: string } {
+  const firstMsg = context?.messages?.[0];
+  if (!firstMsg) {
+    return { conversationId: crypto.randomUUID(), trajectoryId: crypto.randomUUID() };
+  }
+  const contentSeed =
+    typeof firstMsg.content === "string"
+      ? firstMsg.content.slice(0, 64)
+      : Array.isArray(firstMsg.content)
+        ? JSON.stringify(firstMsg.content[0] ?? "").slice(0, 64)
+        : "";
+  const seed = `${firstMsg.role || "user"}:${firstMsg.timestamp || ""}:${contentSeed}`;
+  let entry = sessionTrajectoryMap.get(seed);
+  if (!entry) {
+    entry = {
+      conversationId: stableUuid(`antigravity:conv:${seed}`),
+      trajectoryId: stableUuid(`antigravity:traj:${seed}`),
+    };
+    sessionTrajectoryMap.set(seed, entry);
+    if (sessionTrajectoryMap.size > 64) {
+      const oldestKey = sessionTrajectoryMap.keys().next().value;
+      if (oldestKey !== undefined) sessionTrajectoryMap.delete(oldestKey);
+    }
+  }
+  return entry;
+}
+
+export function clearSessionTrajectoryMap(): void {
+  sessionTrajectoryMap.clear();
+}
+
+export function antigravityRequestEnvelope(
+  wireModelId: string,
+  optionsOrIsClaude: boolean | AntigravityEnvelopeOptions = false,
+): { requestId: string; sessionId: string; labels: Record<string, string> } {
+  const options: AntigravityEnvelopeOptions =
+    typeof optionsOrIsClaude === "boolean" ? { isClaude: optionsOrIsClaude } : optionsOrIsClaude;
+
+  const isClaude = Boolean(options.isClaude);
+  const isNonGemini = Boolean(options.isNonGemini || isClaude);
+  const step = Math.max(1, options.step ?? 1);
+  const lastStepIndex = options.lastStepIndex ?? String(Math.max(0, step - 1));
+  const requestIndex = options.requestIndex ?? options.userTurnIndex ?? Math.max(0, step - 1);
+  const agentId = options.conversationId || crypto.randomUUID();
+  const trajectoryId = options.trajectoryId || crypto.randomUUID();
+  const bytes = crypto.getRandomValues(new Uint8Array(8));
+  const sessionId = String(new DataView(bytes.buffer, bytes.byteOffset, 8).getBigInt64(0, true));
+
+  const claudeLabel = isClaude ? "true" : "false";
+  const nonGeminiLabel = isNonGemini ? "true" : "false";
+
+  const labels: Record<string, string> = {
+    last_step_index: lastStepIndex,
+    request_id: `${trajectoryId}-${requestIndex}`,
+    trajectory_id: trajectoryId,
+    used_claude: claudeLabel,
+    used_claude_conservative: claudeLabel,
+    used_non_gemini_model: nonGeminiLabel,
+  };
+
+  const modelEnum = getModelEnum(wireModelId);
+  if (modelEnum) {
+    labels.model_enum = modelEnum;
+  }
+
+  return {
+    requestId: `agent/${agentId}/${Date.now()}/${trajectoryId}/${step}`,
+    sessionId,
+    labels,
+  };
+}

package/plugins/kxm/src/redact.ts

@@ -4,6 +4,10 @@ const SECRET_PATTERNS: RegExp[] = [
   /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
   /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/gi,
   /\bBearer\s+[A-Za-z0-9._~+/=-]+\b/gi,
+  /\bya29\.[A-Za-z0-9._~+/-]+=*/g,
+  /\b1\/\/[A-Za-z0-9_-]+/g,
+  /\b1\/[A-Za-z0-9_-]{20,}/g,
+  /("?(?:access_token|refresh_token|id_token)"?\s*[:=]\s*")[^"]*(")/gi,
   /\bKXM_[A-Z0-9_]*(TOKEN|SECRET|KEY)[A-Z0-9_]*=\S+/gi,
   /\b(GITHUB_TOKEN|GH_TOKEN|KXM_AUTH_TOKEN|KXM_WORKFLOW_SIGNAL_SECRET)=\S+/gi,
   /\b[A-Fa-f0-9]{64}\b/g,

package/plugins/kxm/src/vnext-engine.ts

@@ -33,7 +33,9 @@ import { gateRegistryHash } from "./vnext-gate-hash.ts";
 import {
   admitVnextRun,
   armVnextGateHold,
+  attachVnextDriveSession,
   bindVnextSchedulerPolicy,
+  clearVnextDriveSession,
   dropVnextGateStopHook,
   enqueueVnextScheduledRun,
   finishVnextOwnedGate,
@@ -47,6 +49,7 @@ import {
   vnextAttemptControllers,
   vnextGateHold,
   vnextSchedulerPolicy,
+  type VnextDriveSession,
 } from "./vnext-runtime-owner.ts";
 import {
   cancelVnextRun,
@@ -161,6 +164,7 @@ export interface VnextProducerResult {
 export interface VnextProducer {
   readonly id: "driver-simulated" | "pi" | "oneshot";
   produce(request: VnextProducerRequest): Promise<VnextProducerResult>;
+  close?(): Promise<void>;
 }
 
 export interface VnextRunHandoff {
@@ -412,13 +416,97 @@ function admitPinnedRun(context: VnextRuntimeContext, runId: string): string {
   );
 }
 
+export interface OpenVnextDriveSessionOptions {
+  mode: "simulated" | "live";
+  allowLimits?: boolean;
+  liveMode?: boolean;
+  createProducer: () => VnextProducer;
+}
+
+export interface VnextDriveSessionHandle {
+  driveId: string;
+  settled: Promise<VnextRunDriveResult>;
+}
+
+function newDriveId(runId: string, token: string, runtimeId: string, monotonicNs: string): string {
+  return `drv_${createHash("sha256").update(`${runId}\0${token}\0${runtimeId}\0${monotonicNs}`, "utf8").digest("hex").slice(0, 24)}`;
+}
+
+function inflightAttemptId(state: VnextRunState): string | undefined {
+  const leftover = unreconciledPanelAttemptId(state);
+  if (leftover) return leftover;
+  if (state.currentStep?.attemptId) {
+    const located = vnextFoldPanelAttempt(state.currentStep, state.currentStep.attemptId);
+    const status = located?.attempt.status;
+    if (status === "starting" || status === "executing" || status === "settling") return state.currentStep.attemptId;
+  }
+  return undefined;
+}
+
+function recordExecutingUnrecordedFailure(context: VnextRuntimeContext, runId: string, attemptId: string, stepId: string): void {
+  context.eventStore.transaction(() => {
+    const run = requireRun(context, runId);
+    const now = new Date().toISOString();
+    const sequence = context.eventStore.nextSequence(runId);
+    const event: VnextRunEvent = {
+      ...vnextEventBase(context, run, now, vnextMonotonicNs()),
+      eventId: newVnextEventId(),
+      eventType: "run.status_changed",
+      sequence,
+      payload: { status: "failed", reason: "executing_unrecorded", stepId },
+    };
+    context.eventStore.appendEvent(event);
+    context.eventStore.settleCapability(attemptId, "revoked");
+    const next = foldStoredVnextRun(context, run);
+    persistVnextRunState(context, runId, next, sequence);
+    context.eventStore.updateRunStatus(runId, "failed", now);
+  });
+}
+
+function recordBareDriveFailure(context: VnextRuntimeContext, runId: string): void {
+  if (isVnextRuntimeContextClosed(context)) return;
+  try {
+    const run = context.eventStore.run(runId);
+    if (!run) return;
+    const state = foldStoredVnextRun(context, run);
+    if (isTerminalRunStatus(state.status) || state.status === "cancelling") return;
+    const inflight = inflightAttemptId(state);
+    if (inflight) {
+      const currentStep = state.currentStep;
+      const located = vnextFoldPanelAttempt(currentStep, inflight);
+      if (currentStep && currentStep.panel.order.length === 1 && located?.attempt.status === "starting") {
+        const plan = rehydrateVnextCompiledPlanFromStore(context.eventStore, run);
+        const step = plan.steps[currentStep.stepId];
+        if (step?.kind === "gate") return;
+        if (step && (step.kind === "agent" || step.kind === "moa") && step.assignments.maximum > 1) return;
+        recordExecutingUnrecordedFailure(context, runId, inflight, currentStep.stepId);
+      }
+      return;
+    }
+    cancelVnextRun(context, runId, { reason: "drive_error" });
+  } catch {
+    // The original drive error governs; this is a best-effort bare-running brake.
+  }
+}
+
+async function closeDriveProducer(producer: VnextProducer): Promise<void> {
+  if (typeof producer.close !== "function") return;
+  try {
+    await producer.close();
+  } catch {
+    // Session ownership ends even if producer cleanup fails.
+  }
+}
+
 export class VnextRunScheduler {
   private readonly context: VnextRuntimeContext;
+  private readonly bundle: VnextProjectBundle;
   private readonly configRevision: string;
 
-  private constructor(context: VnextRuntimeContext, configRevision: string) {
+  private constructor(context: VnextRuntimeContext, bundle: VnextProjectBundle) {
     this.context = context;
-    this.configRevision = configRevision;
+    this.bundle = bundle;
+    this.configRevision = bundle.configRevision;
   }
 
   static for(context: VnextRuntimeContext, bundle: VnextProjectBundle): VnextRunScheduler {
@@ -427,7 +515,7 @@ export class VnextRunScheduler {
     }
     const limits = vnextProjectAdmissionLimits(bundle);
     bindVnextSchedulerPolicy(context.eventStore.path, limits.maxConcurrentRuns, bundle.configRevision);
-    return new VnextRunScheduler(context, bundle.configRevision);
+    return new VnextRunScheduler(context, bundle);
   }
 
   enqueue(
@@ -454,6 +542,94 @@ export class VnextRunScheduler {
       return Promise.reject(error);
     }
   }
+
+  openDriveSession(runId: string, options: OpenVnextDriveSessionOptions): Promise<VnextDriveSessionHandle> {
+    const policy = vnextSchedulerPolicy(this.context.eventStore.path);
+    if (!policy || policy.configRevision !== this.configRevision) {
+      return Promise.reject(runtimeError("scheduler_policy_conflict", runId, "scheduler handle does not match the active policy"));
+    }
+    try {
+      const run = requireRun(this.context, runId);
+      if (isTerminalRunStatus(run.status) || run.status === "cancelling") {
+        return Promise.reject(runtimeError("run_busy", runId, `run ${runId} is already ${run.status}`));
+      }
+    } catch (error) {
+      return Promise.reject(error);
+    }
+
+    const limits = vnextProjectAdmissionLimits(this.bundle);
+    const driveOptions: { allowLimits?: boolean; liveMode?: boolean } = {
+      liveMode: options.liveMode ?? options.mode === "live",
+    };
+    if (options.allowLimits !== undefined) driveOptions.allowLimits = options.allowLimits;
+    let opened = false;
+    const pending = {
+      resolve: (_value: VnextRunDriveResult) => undefined as void,
+      reject: (_error: unknown) => undefined as void,
+    };
+    const settled = new Promise<VnextRunDriveResult>((resolve, reject) => {
+      pending.resolve = resolve;
+      pending.reject = reject;
+    });
+    void settled.then(undefined, () => undefined);
+
+    return new Promise<VnextDriveSessionHandle>((resolveOpen, rejectOpen) => {
+      const queued = enqueueVnextScheduledRun(
+        this.context.eventStore.path,
+        runId,
+        this.configRevision,
+        limits.maxConcurrentRuns,
+        async (token) => {
+          let producer: VnextProducer | undefined;
+          try {
+            producer = options.createProducer();
+            requireTrustedProducer(producer);
+            const current = requireRun(this.context, runId);
+            if (current.status === "created") {
+              pinVnextCompiledPlan(this.context, this.bundle, runId);
+            }
+            const started = startVnextRun(this.context, runId, driveOptions);
+            if (started.handoff) {
+              const error = runtimeError("run_handoff_required", runId, started.handoff.detail);
+              Object.assign(error, { handoff: started.handoff });
+              throw error;
+            }
+            const driveId = newDriveId(runId, token, this.context.homeRuntimeId, vnextMonotonicNs());
+            const session: VnextDriveSession = {
+              driveId,
+              runId,
+              token,
+              homeRuntimeId: this.context.homeRuntimeId,
+              mode: options.mode,
+              openedAt: new Date().toISOString(),
+              controller: new AbortController(),
+              settled,
+            };
+            attachVnextDriveSession(this.context.eventStore.path, runId, token, session);
+            opened = true;
+            resolveOpen({ driveId, settled });
+            try {
+              const result = await driveAdmitted(this.context, runId, producer, token, driveOptions);
+              pending.resolve(result);
+              return result;
+            } catch (error) {
+              recordBareDriveFailure(this.context, runId);
+              pending.reject(error);
+              throw error;
+            }
+          } finally {
+            if (producer) await closeDriveProducer(producer);
+            clearVnextDriveSession(this.context.eventStore.path, runId, token);
+          }
+        },
+      ) as Promise<VnextRunDriveResult>;
+      void queued.then(undefined, (error) => {
+        if (!opened) {
+          rejectOpen(error);
+        }
+      });
+    });
+  }
 }
 
 export function verifyVnextAttemptCapability(
@@ -893,6 +1069,7 @@ export interface VnextPanelDispatchSeams {
   failAppendExecuting?: ((member: VnextPanelMemberHook) => boolean) | undefined;
   beforeInvoke?: ((member: VnextPanelMemberHook) => void) | undefined;
   failSettleMember?: ((member: VnextPanelMemberHook) => boolean) | undefined;
+  skipDispatch?: (() => boolean) | undefined;
 }
 
 export const vnextPanelDispatchSeams: VnextPanelDispatchSeams = {};
@@ -993,6 +1170,9 @@ function prepareDispatch(
   const run = requireRun(context, runId);
   const plan = rehydrateVnextCompiledPlanFromStore(context.eventStore, run);
   const state = foldStoredVnextRun(context, run);
+  if (vnextPanelDispatchSeams.skipDispatch?.()) {
+    return { kind: "return", state };
+  }
   if (state.status === "cancelling" && vnextAttemptControllers(context.eventStore.path, runId).length === 0) {
     return {
       kind: "return",

package/plugins/kxm/src/vnext-runtime-owner.ts

@@ -19,10 +19,22 @@ interface GateHold {
   stop?: () => void;
 }
 
+export interface VnextDriveSession {
+  driveId: string;
+  runId: string;
+  token: string;
+  homeRuntimeId: string;
+  mode: "simulated" | "live";
+  openedAt: string;
+  controller: AbortController;
+  settled: Promise<unknown>;
+}
+
 interface AdmissionRecord {
   token: string;
   configRevision: string;
   gateHold?: GateHold;
+  driveSession?: VnextDriveSession;
 }
 
 interface QueueItem {
@@ -270,6 +282,44 @@ export function vnextAdmittedToken(storePath: string, runId: string): string | u
   return owners.get(storePath)?.admitted.get(runId)?.token;
 }
 
+export function attachVnextDriveSession(
+  storePath: string,
+  runId: string,
+  token: string,
+  session: VnextDriveSession,
+): void {
+  const owner = record(storePath);
+  const current = owner.admitted.get(runId);
+  if (!current || current.token !== token) {
+    throw runtimeError("run_events_illegal", runId, "drive session requires the exact admitted token");
+  }
+  if (current.driveSession) {
+    throw runtimeError("run_busy", runId, `run ${runId} already has a drive session`);
+  }
+  current.driveSession = session;
+}
+
+export function clearVnextDriveSession(storePath: string, runId: string, token: string): void {
+  const owner = owners.get(storePath);
+  const current = owner?.admitted.get(runId);
+  if (!current || current.token !== token) return;
+  delete current.driveSession;
+}
+
+export function vnextDriveSession(storePath: string, runId: string): VnextDriveSession | undefined {
+  return owners.get(storePath)?.admitted.get(runId)?.driveSession;
+}
+
+export function vnextOpenDriveSessions(storePath: string): VnextDriveSession[] {
+  const owner = owners.get(storePath);
+  if (!owner) return [];
+  const sessions: VnextDriveSession[] = [];
+  for (const current of owner.admitted.values()) {
+    if (current.driveSession) sessions.push(current.driveSession);
+  }
+  return sessions;
+}
+
 export function enqueueVnextScheduledRun(
   storePath: string,
   runId: string,