fix: rekey ACP metadata during session key migration

shakkernerd · shakkernerd · commit 440284f87955 · 2026-06-09T22:07:05.000+01:00
diff --git a/src/acp/runtime/session-meta.test.ts b/src/acp/runtime/session-meta.test.ts
@@ -8,7 +8,9 @@ import { closeOpenClawStateDatabaseForTest } from "../../state/openclaw-state-db
 import { withTempDir } from "../../test-helpers/temp-dir.js";
 import {
   listAcpSessionEntries,
+  moveAcpSessionMetaForMigration,
   readAcpSessionEntry,
+  readAcpSessionMetaForEntry,
   upsertAcpSessionMeta,
   writeAcpSessionMetaForMigration,
 } from "./session-meta.js";
@@ -213,6 +215,57 @@ describe("ACP session metadata SQLite store", () => {
     });
   });
 
+  it("moves ACP metadata rows when session-store keys are canonicalized", async () => {
+    await withTempDir({ prefix: "openclaw-acp-meta-" }, async (dir) => {
+      const storePath = path.join(dir, "sessions.json");
+      const databasePath = path.join(dir, "state", "openclaw.sqlite");
+      const cfg = { session: { store: storePath } } as OpenClawConfig;
+      const legacyKey = "agent:CODEX:acp:legacy-runtime";
+      const canonicalKey = "agent:codex:acp:legacy-runtime";
+      await writeSessionStoreForTestAsync(storePath, {
+        [canonicalKey]: {
+          sessionId: "sess-acp",
+          updatedAt: 100,
+        },
+      });
+      writeAcpSessionMetaForMigration({
+        databasePath,
+        sessionKey: legacyKey,
+        sessionId: "sess-acp",
+        meta: {
+          backend: "acpx",
+          agent: "codex",
+          runtimeSessionName: legacyKey,
+          mode: "persistent",
+          state: "idle",
+          lastActivityAt: 123,
+        },
+      });
+
+      expect(
+        moveAcpSessionMetaForMigration({
+          databasePath,
+          fromSessionKey: legacyKey,
+          toSessionKey: canonicalKey,
+          entry: { sessionId: "sess-acp" },
+          now: () => 200,
+        }),
+      ).toBe(true);
+
+      expect(
+        readAcpSessionMetaForEntry({
+          databasePath,
+          sessionKey: legacyKey,
+          entry: { sessionId: "sess-acp" },
+        }),
+      ).toBeUndefined();
+      expect(
+        readAcpSessionEntry({ cfg, databasePath, sessionKey: canonicalKey })?.acp
+          ?.runtimeSessionName,
+      ).toBe(legacyKey);
+    });
+  });
+
   it("lists SQLite ACP rows while joining current session-store entries", async () => {
     await withTempDir({ prefix: "openclaw-acp-meta-" }, async (dir) => {
       const storePath = path.join(dir, "sessions", "codex.json");
diff --git a/src/acp/runtime/session-meta.ts b/src/acp/runtime/session-meta.ts
@@ -157,7 +157,10 @@ function selectAcpSessionRow(db: DatabaseSync, sessionKey: string): AcpSessionRo
   );
 }
 
-function acpSessionRowMatchesEntry(row: AcpSessionRow, entry: SessionEntry | undefined): boolean {
+function acpSessionRowMatchesEntry(
+  row: AcpSessionRow,
+  entry: Pick<SessionEntry, "sessionId"> | undefined,
+): boolean {
   // Rows tied to a specific sessionId are stale after the JSON session entry rotates.
   return row.session_id == null || row.session_id === entry?.sessionId;
 }
@@ -191,7 +194,7 @@ export function readAcpSessionMeta(params: {
 
 export function readAcpSessionMetaForEntry(params: {
   sessionKey: string;
-  entry: SessionEntry | undefined;
+  entry: Pick<SessionEntry, "sessionId"> | undefined;
   env?: NodeJS.ProcessEnv;
   databasePath?: string;
 }): SessionAcpMeta | undefined {
@@ -248,6 +251,45 @@ export function writeAcpSessionMetaForMigration(params: {
   );
 }
 
+export function moveAcpSessionMetaForMigration(params: {
+  fromSessionKey: string;
+  toSessionKey: string;
+  entry?: Pick<SessionEntry, "sessionId">;
+  env?: NodeJS.ProcessEnv;
+  databasePath?: string;
+  now?: () => number;
+}): boolean {
+  const fromSessionKey = params.fromSessionKey.trim();
+  const toSessionKey = params.toSessionKey.trim();
+  if (!fromSessionKey || !toSessionKey || fromSessionKey === toSessionKey) {
+    return false;
+  }
+
+  let moved = false;
+  runOpenClawStateWriteTransaction(
+    (database) => {
+      const row = selectAcpSessionRow(database.db, fromSessionKey);
+      if (!row || !acpSessionRowMatchesEntry(row, params.entry)) {
+        return;
+      }
+      upsertAcpSessionMetaRow(database.db, {
+        ...row,
+        session_key: toSessionKey,
+        updated_at: params.now?.() ?? Date.now(),
+      });
+      executeSqliteQuerySync(
+        database.db,
+        getAcpSessionKysely(database.db)
+          .deleteFrom("acp_sessions")
+          .where("session_key", "=", fromSessionKey),
+      );
+      moved = true;
+    },
+    { env: params.env, path: params.databasePath },
+  );
+  return moved;
+}
+
 function upsertAcpSessionMetaRow(db: DatabaseSync, row: Insertable<AcpSessionsTable>): void {
   executeSqliteQuerySync(
     db,
diff --git a/src/gateway/sessions-resolve-store.test.ts b/src/gateway/sessions-resolve-store.test.ts
@@ -295,6 +295,13 @@ describe("resolveSessionKeyFromResolveParams store canonicalization", () => {
           p: { key: acpKey },
         }),
       ).resolves.toEqual({ ok: true, key: acpKey });
+
+      await expect(
+        resolveSessionKeyFromResolveParams({
+          cfg,
+          p: { key: acpKey },
+        }),
+      ).resolves.toEqual({ ok: true, key: acpKey });
     });
   });
 
diff --git a/src/gateway/sessions-resolve.ts b/src/gateway/sessions-resolve.ts
@@ -7,9 +7,11 @@ import {
   errorShape,
   type SessionsResolveParams,
 } from "../../packages/gateway-protocol/src/index.js";
+import { moveAcpSessionMetaForMigration } from "../acp/runtime/session-meta.js";
 import { loadSessionStore, updateSessionStore, type SessionEntry } from "../config/sessions.js";
 import type { OpenClawConfig } from "../config/types.openclaw.js";
 import { resolveSessionIdMatchSelection } from "../sessions/session-id-resolution.js";
+import { isAcpSessionKey } from "../sessions/session-key-utils.js";
 import { parseSessionLabel } from "../sessions/session-label.js";
 import {
   filterAndSortSessionEntries,
@@ -161,6 +163,13 @@ export async function resolveSessionKeyFromResolveParams(params: {
       }
     });
     const migratedStore = loadSessionStore(target.storePath);
+    if (isAcpSessionKey(target.canonicalKey) || isAcpSessionKey(legacyKey)) {
+      moveAcpSessionMetaForMigration({
+        fromSessionKey: legacyKey,
+        toSessionKey: target.canonicalKey,
+        entry: migratedStore[target.canonicalKey],
+      });
+    }
     if (
       !isResolvedSessionKeyVisible({
         cfg,
