| |
| import fs from "node:fs"; |
| import path from "node:path"; |
| import { DatabaseSync } from "node:sqlite"; |
| import { afterEach, describe, expect, it, vi } from "vitest"; |
| import type { OpenClawConfig } from "../../config/config.js"; |
| import { retainLegacyDefaultAgentId } from "../../config/legacy.default-agent-owner.js"; |
| import { loadSessionEntry, replaceSessionEntry } from "../../config/sessions/session-accessor.js"; |
| import type { SessionEntry } from "../../config/sessions/types.js"; |
| import { closeOpenClawAgentDatabasesForTest } from "../../state/openclaw-agent-db.js"; |
| import { closeOpenClawStateDatabaseForTest } from "../../state/openclaw-state-db.js"; |
| import { claimOpenClawStateOwnership } from "../../state/openclaw-state-ownership-operations.js"; |
| import { withTestDir } from "../../test-helpers/temp-dir.js"; |
| import { |
| listAcpSessionEntries, |
| readAcpSessionEntry, |
| readAcpSessionMeta, |
| readAcpSessionMetaBatch, |
| readAcpSessionMetaForEntry, |
| repairAcpSessionMetaKeyForMigration, |
| upsertAcpSessionMeta, |
| writeAcpSessionMetaForMigration, |
| } from "./session-meta.js"; |
|
|
| const ACP_AGENT_ID = "codex"; |
|
|
| async function seedAcpSessionEntry(params: { |
| storePath: string; |
| sessionKey: string; |
| entry: SessionEntry; |
| }): Promise<void> { |
| await replaceSessionEntry( |
| { |
| agentId: ACP_AGENT_ID, |
| storePath: params.storePath, |
| sessionKey: params.sessionKey, |
| }, |
| params.entry, |
| ); |
| } |
|
|
| function readStoredAcpSessionEntry(params: { |
| storePath: string; |
| sessionKey: string; |
| }): SessionEntry | undefined { |
| return loadSessionEntry({ |
| agentId: ACP_AGENT_ID, |
| storePath: params.storePath, |
| sessionKey: params.sessionKey, |
| }); |
| } |
|
|
| describe("ACP session metadata SQLite store", () => { |
| afterEach(() => { |
| closeOpenClawAgentDatabasesForTest(); |
| closeOpenClawStateDatabaseForTest(); |
| }); |
|
|
| it("persists bare global metadata under a configured fixed-store owner", async () => { |
| await withTestDir({ prefix: "openclaw-acp-global-owner-" }, async (dir) => { |
| const storePath = path.join(dir, "sessions.json"); |
| const cfg = { |
| session: { scope: "global", store: storePath }, |
| agents: { |
| ownership: "explicit", |
| defaults: { sessionStore: { agentId: "ops" } }, |
| entries: { ops: {}, research: {} }, |
| }, |
| } satisfies OpenClawConfig; |
| const databasePath = path.join(dir, "state", "openclaw.sqlite"); |
| await replaceSessionEntry( |
| { |
| agentId: "ops", |
| storePath, |
| sessionKey: "global", |
| }, |
| { sessionId: "ops-global", updatedAt: 100, sessionStartedAt: 100 }, |
| ); |
| const mutate = () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "global", |
| mode: "persistent" as const, |
| state: "idle" as const, |
| lastActivityAt: 123, |
| }); |
|
|
| const persisted = await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: "global", |
| mutate, |
| }); |
|
|
| expect(persisted?.acp?.runtimeSessionName).toBe("global"); |
| expect( |
| readAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: "global", |
| })?.runtimeSessionName, |
| ).toBe("global"); |
| const conflictingMutate = vi.fn(mutate); |
| await expect( |
| upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: "global", |
| agentId: "research", |
| mutate: conflictingMutate, |
| }), |
| ).rejects.toMatchObject({ code: "AGENT_SELECTION_REQUIRED" }); |
| expect(conflictingMutate).not.toHaveBeenCalled(); |
| const ownerlessCfg = { |
| ...cfg, |
| agents: { ownership: "explicit", entries: { ops: {}, research: {} } }, |
| } satisfies OpenClawConfig; |
| const ownerlessMutate = vi.fn(mutate); |
| await expect( |
| upsertAcpSessionMeta({ |
| cfg: ownerlessCfg, |
| databasePath, |
| sessionKey: "ownerless-global", |
| mutate: ownerlessMutate, |
| }), |
| ).rejects.toMatchObject({ code: "AGENT_SELECTION_REQUIRED" }); |
| expect(ownerlessMutate).not.toHaveBeenCalled(); |
| }); |
| }); |
|
|
| it("reads metadata under external state ownership without write admission", async () => { |
| await withTestDir({ prefix: "openclaw-acp-read-only-owner-" }, async (dir) => { |
| const env = { OPENCLAW_STATE_DIR: dir }; |
| const externalEnv = { ...env, OPENCLAW_SUPERVISOR_MODE: "external" }; |
| const cfg = { |
| agents: { ownership: "explicit", entries: { main: {} } }, |
| } satisfies OpenClawConfig; |
| const databasePath = path.join(dir, "state", "openclaw.sqlite"); |
| const storePath = path.join(dir, "agents", "main", "agent", "openclaw-agent.sqlite"); |
| const sessionKey = "agent:main:proof"; |
| await replaceSessionEntry( |
| { agentId: "main", storePath, sessionKey }, |
| { sessionId: "proof-session", updatedAt: 100 }, |
| ); |
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| env, |
| sessionKey, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "proof-runtime", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 100, |
| }), |
| }); |
| closeOpenClawStateDatabaseForTest(); |
| claimOpenClawStateOwnership("test-supervisor", { env: externalEnv }); |
| closeOpenClawStateDatabaseForTest(); |
| const before = fs.readFileSync(databasePath); |
|
|
| expect(readAcpSessionMeta({ cfg, databasePath, env, sessionKey })).toMatchObject({ |
| runtimeSessionName: "proof-runtime", |
| }); |
| expect(fs.readFileSync(databasePath)).toEqual(before); |
| }); |
| }); |
|
|
| it("keeps identical bare keys isolated by explicit agent owner", async () => { |
| await withTestDir({ prefix: "openclaw-acp-pair-owner-" }, async (dir) => { |
| const storePath = path.join(dir, "sessions.json"); |
| const databasePath = path.join(dir, "state", "openclaw.sqlite"); |
| const cfg = { |
| session: { store: storePath }, |
| agents: { ownership: "explicit", entries: { research: {}, ops: {} } }, |
| } satisfies OpenClawConfig; |
| for (const agentId of ["research", "ops"]) { |
| await replaceSessionEntry( |
| { agentId, storePath, sessionKey: "global" }, |
| { sessionId: `${agentId}-global`, updatedAt: 100 }, |
| ); |
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: "global", |
| agentId, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: agentId, |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }), |
| }); |
| } |
|
|
| expect( |
| readAcpSessionMeta({ cfg, databasePath, sessionKey: "global", agentId: "research" }) |
| ?.runtimeSessionName, |
| ).toBe("research"); |
| expect( |
| readAcpSessionMeta({ cfg, databasePath, sessionKey: "global", agentId: "ops" }) |
| ?.runtimeSessionName, |
| ).toBe("ops"); |
|
|
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: "global", |
| agentId: "research", |
| mutate: () => null, |
| }); |
| expect( |
| readAcpSessionMeta({ cfg, databasePath, sessionKey: "global", agentId: "ops" }) |
| ?.runtimeSessionName, |
| ).toBe("ops"); |
| }); |
| }); |
|
|
| it.each(["persisted", "sole", "retained"] as const)( |
| "batch-loads legacy bare metadata without rekeying during a read (%s owner)", |
| async (ownerKind) => { |
| await withTestDir({ prefix: "openclaw-acp-batch-owner-" }, async (dir) => { |
| const databasePath = path.join(dir, "state", "openclaw.sqlite"); |
| const cfg: OpenClawConfig = { |
| session: { store: path.join(dir, "sessions.json") }, |
| agents: { |
| ownership: "explicit", |
| defaults: |
| ownerKind === "persisted" |
| ? { sessionStore: { agentId: "ops" } } |
| : ownerKind === "retained" |
| ? { systemAgent: { agentId: "research" } } |
| : undefined, |
| entries: ownerKind === "sole" ? { ops: {} } : { ops: {}, research: {} }, |
| }, |
| }; |
| retainLegacyDefaultAgentId(cfg, ownerKind === "retained" ? "ops" : undefined); |
| const entry: SessionEntry = { |
| sessionId: "ops-global", |
| lifecycleRevision: "ops-revision", |
| updatedAt: 100, |
| }; |
| const staleEntry: SessionEntry = { ...entry, lifecycleRevision: "ops-next" }; |
| const otherOwnerEntry: SessionEntry = { ...entry }; |
| writeAcpSessionMetaForMigration({ |
| databasePath, |
| sessionKey: "global", |
| lifecycleRevision: "ops-revision", |
| meta: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "legacy-global", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }, |
| }); |
|
|
| const batch = readAcpSessionMetaBatch({ |
| cfg, |
| databasePath, |
| entries: [ |
| { sessionKey: "global", agentId: "ops", entry }, |
| { sessionKey: "global", agentId: "ops", entry: staleEntry }, |
| { sessionKey: "global", agentId: "research", entry: otherOwnerEntry }, |
| ], |
| }); |
|
|
| expect([ |
| batch.get(entry)?.runtimeSessionName, |
| batch.get(otherOwnerEntry)?.runtimeSessionName, |
| ]).toEqual(["legacy-global", undefined]); |
| expect(batch.get(staleEntry)).toBeUndefined(); |
| expect( |
| ["ops", "research"].map( |
| (agentId) => |
| readAcpSessionMetaForEntry({ |
| cfg, |
| databasePath, |
| sessionKey: "global", |
| agentId, |
| entry, |
| })?.runtimeSessionName, |
| ), |
| ).toEqual(["legacy-global", undefined]); |
| expect( |
| readAcpSessionMetaForEntry({ |
| cfg, |
| databasePath, |
| sessionKey: "global", |
| agentId: "ops", |
| entry: staleEntry, |
| }), |
| ).toBeUndefined(); |
| expect( |
| readAcpSessionMetaForEntry({ databasePath, sessionKey: "global", entry }) |
| ?.runtimeSessionName, |
| ).toBe("legacy-global"); |
| expect( |
| readAcpSessionMetaForEntry({ databasePath, sessionKey: "global", entry: staleEntry }), |
| ).toBeUndefined(); |
| const database = new DatabaseSync(databasePath, { |
| readOnly: true, |
| }); |
| try { |
| expect( |
| database.prepare("SELECT session_key FROM acp_sessions ORDER BY session_key").all(), |
| ).toEqual([{ session_key: "global" }]); |
| } finally { |
| database.close(); |
| } |
| }); |
| }, |
| ); |
|
|
| it("deletes the legacy row selected by fallback when metadata is cleared", async () => { |
| await withTestDir({ prefix: "openclaw-acp-clear-legacy-owner-" }, async (dir) => { |
| const storePath = path.join(dir, "sessions.json"); |
| const databasePath = path.join(dir, "state", "openclaw.sqlite"); |
| const cfg = { |
| session: { scope: "global", store: storePath }, |
| agents: { |
| ownership: "explicit", |
| defaults: { sessionStore: { agentId: "ops" } }, |
| entries: { ops: {}, research: {} }, |
| }, |
| } satisfies OpenClawConfig; |
| const entry: SessionEntry = { |
| sessionId: "ops-global", |
| lifecycleRevision: "ops-revision", |
| updatedAt: 100, |
| }; |
| await replaceSessionEntry({ agentId: "ops", storePath, sessionKey: "global" }, entry); |
| writeAcpSessionMetaForMigration({ |
| databasePath, |
| sessionKey: "global", |
| lifecycleRevision: "ops-revision", |
| meta: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "legacy-global", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }, |
| }); |
|
|
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: "global", |
| mutate: (current) => { |
| expect(current?.runtimeSessionName).toBe("legacy-global"); |
| return null; |
| }, |
| }); |
|
|
| expect(readAcpSessionMeta({ cfg, databasePath, sessionKey: "global" })).toBeUndefined(); |
| }); |
| }); |
|
|
| it("escapes composite identities from legacy raw keys that use the old prefix", async () => { |
| await withTestDir({ prefix: "openclaw-acp-prefix-collision-" }, async (dir) => { |
| const databasePath = path.join(dir, "state", "openclaw.sqlite"); |
| const rawSessionKey = "@agent:research:foo"; |
| const rawEntry: SessionEntry = { |
| sessionId: "raw-session", |
| lifecycleRevision: "raw-revision", |
| updatedAt: 100, |
| }; |
| writeAcpSessionMetaForMigration({ |
| databasePath, |
| sessionKey: rawSessionKey, |
| lifecycleRevision: "raw-revision", |
| meta: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "literal-prefix-key", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }, |
| }); |
|
|
| const batch = readAcpSessionMetaBatch({ |
| databasePath, |
| entries: [{ sessionKey: rawSessionKey, entry: rawEntry }], |
| }); |
| expect(batch.get(rawEntry)?.runtimeSessionName).toBe("literal-prefix-key"); |
| expect( |
| readAcpSessionMetaForEntry({ databasePath, sessionKey: rawSessionKey, entry: rawEntry }) |
| ?.runtimeSessionName, |
| ).toBe("literal-prefix-key"); |
| expect( |
| readAcpSessionMetaForEntry({ |
| databasePath, |
| sessionKey: "foo", |
| agentId: "research", |
| entry: { |
| sessionId: "other-session", |
| lifecycleRevision: "other-revision", |
| }, |
| }), |
| ).toBeUndefined(); |
| }); |
| }); |
|
|
| it("persists ACP metadata in SQLite without writing sessions.json acp blocks", async () => { |
| await withTestDir({ 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 sessionKey = "agent:codex:acp:binding:discord:default:feedface"; |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey, |
| entry: { |
| sessionId: "sess-acp", |
| updatedAt: 100, |
| }, |
| }); |
|
|
| const result = await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey, |
| now: () => 200, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-discord", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| cwd: "/repo", |
| }), |
| }); |
|
|
| expect(result?.acp?.runtimeSessionName).toBe("codex-discord"); |
| expect(fs.existsSync(storePath)).toBe(false); |
| expect( |
| readAcpSessionEntry({ |
| cfg, |
| databasePath, |
| sessionKey, |
| })?.acp, |
| ).toMatchObject({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-discord", |
| mode: "persistent", |
| state: "idle", |
| cwd: "/repo", |
| }); |
| }); |
| }); |
|
|
| it("clears legacy embedded ACP metadata through the session accessor", async () => { |
| await withTestDir({ 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 sessionKey = "agent:codex:acp:binding:discord:default:feedface"; |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey, |
| entry: { |
| sessionId: "sess-acp", |
| updatedAt: 100, |
| acp: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "legacy-embedded", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 120, |
| }, |
| }, |
| }); |
|
|
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey, |
| now: () => 200, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-sqlite", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }), |
| }); |
|
|
| expect(readStoredAcpSessionEntry({ storePath, sessionKey })?.acp).toBeUndefined(); |
| expect( |
| readAcpSessionEntry({ |
| cfg, |
| databasePath, |
| sessionKey, |
| })?.acp?.runtimeSessionName, |
| ).toBe("codex-sqlite"); |
| }); |
| }); |
|
|
| it("creates a session-store row for new SQLite ACP sessions without embedding ACP metadata", async () => { |
| await withTestDir({ 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 sessionKey = "agent:codex:acp:new-session"; |
|
|
| const result = await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey, |
| now: () => 200, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-new", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }), |
| }); |
|
|
| expect(result?.sessionId).toEqual(expect.any(String)); |
| expect(result?.acp?.runtimeSessionName).toBe("codex-new"); |
| const storedEntry = readStoredAcpSessionEntry({ storePath, sessionKey }); |
| expect(storedEntry?.sessionId).toEqual(expect.any(String)); |
| expect(storedEntry?.updatedAt).toEqual(expect.any(Number)); |
| expect(storedEntry?.sessionStartedAt).toBeGreaterThan(200); |
| expect(storedEntry?.acp).toBeUndefined(); |
| expect(readAcpSessionEntry({ cfg, databasePath, sessionKey })?.acp?.runtimeSessionName).toBe( |
| "codex-new", |
| ); |
| expect(readAcpSessionMeta({ cfg, databasePath, sessionKey })?.runtimeSessionName).toBe( |
| "codex-new", |
| ); |
| expect(await listAcpSessionEntries({ cfg, databasePath })).toHaveLength(1); |
| }); |
| }); |
|
|
| it("normalizes ACP metadata lookups and writes to the resolved session-store key", async () => { |
| await withTestDir({ 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 storeSessionKey = "agent:codex:acp:binding:discord:default:feedface"; |
| const rawSessionKey = storeSessionKey.toUpperCase(); |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey: storeSessionKey, |
| entry: { |
| sessionId: "sess-acp", |
| updatedAt: 100, |
| }, |
| }); |
|
|
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: rawSessionKey, |
| now: () => 200, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-normalized", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }), |
| }); |
|
|
| expect( |
| readAcpSessionEntry({ |
| cfg, |
| databasePath, |
| sessionKey: rawSessionKey, |
| })?.acp?.runtimeSessionName, |
| ).toBe("codex-normalized"); |
| expect( |
| readAcpSessionEntry({ |
| cfg, |
| databasePath, |
| sessionKey: storeSessionKey, |
| })?.acp?.runtimeSessionName, |
| ).toBe("codex-normalized"); |
| expect( |
| readAcpSessionMeta({ cfg, databasePath, sessionKey: ` ${rawSessionKey} ` }) |
| ?.runtimeSessionName, |
| ).toBe("codex-normalized"); |
| expect(fs.existsSync(storePath)).toBe(false); |
| const legacyEmbeddedEntry = readStoredAcpSessionEntry({ |
| storePath, |
| sessionKey: storeSessionKey, |
| }); |
| expect(legacyEmbeddedEntry).toBeDefined(); |
| if (!legacyEmbeddedEntry) { |
| throw new Error("expected normalized ACP session entry"); |
| } |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey: storeSessionKey, |
| entry: { |
| ...legacyEmbeddedEntry, |
| acp: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "legacy-embedded", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 120, |
| }, |
| }, |
| }); |
|
|
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: rawSessionKey, |
| mutate: (current) => { |
| expect(current?.runtimeSessionName).toBe("codex-normalized"); |
| return null; |
| }, |
| }); |
|
|
| expect( |
| readAcpSessionEntry({ |
| cfg, |
| databasePath, |
| sessionKey: storeSessionKey, |
| })?.acp, |
| ).toBeUndefined(); |
| expect( |
| readStoredAcpSessionEntry({ storePath, sessionKey: storeSessionKey })?.acp, |
| ).toBeUndefined(); |
| }); |
| }); |
|
|
| it("keeps SQLite ACP metadata visible when legacy store keys are canonicalized", async () => { |
| await withTestDir({ 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 legacyStoreSessionKey = "agent:CODEX:acp:legacy-runtime"; |
| const canonicalSessionKey = "agent:codex:acp:legacy-runtime"; |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey: legacyStoreSessionKey, |
| entry: { |
| sessionId: "sess-acp", |
| updatedAt: 100, |
| }, |
| }); |
|
|
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: canonicalSessionKey, |
| now: () => 200, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-canonicalized", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }), |
| }); |
|
|
| expect( |
| readStoredAcpSessionEntry({ storePath, sessionKey: canonicalSessionKey })?.sessionId, |
| ).toBe("sess-acp"); |
| expect( |
| readAcpSessionEntry({ |
| cfg, |
| databasePath, |
| sessionKey: canonicalSessionKey, |
| })?.acp?.runtimeSessionName, |
| ).toBe("codex-canonicalized"); |
| expect(await listAcpSessionEntries({ cfg, databasePath })).toHaveLength(1); |
| }); |
| }); |
|
|
| it("binds ACP metadata to the final accessor-selected entry for alias writes", async () => { |
| await withTestDir({ 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 canonicalSessionKey = "agent:codex:acp:alias-runtime"; |
| const legacyStoreSessionKey = "agent:CODEX:acp:alias-runtime"; |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey: canonicalSessionKey, |
| entry: { |
| sessionId: "sess-canonical", |
| updatedAt: 100, |
| }, |
| }); |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey: legacyStoreSessionKey, |
| entry: { |
| sessionId: "sess-legacy", |
| updatedAt: 150, |
| }, |
| }); |
|
|
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey: legacyStoreSessionKey, |
| now: () => 200, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-alias", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }), |
| }); |
|
|
| expect( |
| readStoredAcpSessionEntry({ storePath, sessionKey: canonicalSessionKey })?.sessionId, |
| ).toBe("sess-legacy"); |
| expect( |
| readAcpSessionEntry({ |
| cfg, |
| databasePath, |
| sessionKey: canonicalSessionKey, |
| })?.acp?.runtimeSessionName, |
| ).toBe("codex-alias"); |
| expect(await listAcpSessionEntries({ cfg, databasePath })).toHaveLength(1); |
| }); |
| }); |
|
|
| it("ignores SQLite ACP metadata rows from an older lifecycle revision", async () => { |
| await withTestDir({ 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 sessionKey = "agent:codex:acp:binding:discord:default:feedface"; |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey, |
| entry: { |
| sessionId: "sess-new", |
| lifecycleRevision: "revision-new", |
| updatedAt: 100, |
| }, |
| }); |
|
|
| writeAcpSessionMetaForMigration({ |
| databasePath, |
| sessionKey, |
| lifecycleRevision: "revision-old", |
| meta: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-stale", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }, |
| }); |
|
|
| expect(readAcpSessionEntry({ cfg, databasePath, sessionKey })?.acp).toBeUndefined(); |
| expect(readAcpSessionMeta({ cfg, databasePath, sessionKey })).toBeUndefined(); |
| expect(await listAcpSessionEntries({ cfg, databasePath })).toHaveLength(0); |
|
|
| writeAcpSessionMetaForMigration({ |
| databasePath, |
| sessionKey, |
| lifecycleRevision: "revision-new", |
| meta: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-current", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 124, |
| }, |
| }); |
|
|
| expect(readAcpSessionEntry({ cfg, databasePath, sessionKey })?.acp?.runtimeSessionName).toBe( |
| "codex-current", |
| ); |
| expect(await listAcpSessionEntries({ cfg, databasePath })).toHaveLength(1); |
| }); |
| }); |
|
|
| it("reads ACP metadata rows written with the legacy session-id binding", async () => { |
| await withTestDir({ 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 sessionKey = "agent:codex:acp:binding:discord:default:legacy"; |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey, |
| entry: { |
| sessionId: "sess-existing", |
| lifecycleRevision: "revision-existing", |
| sessionStartedAt: 50, |
| updatedAt: 100, |
| }, |
| }); |
| |
| writeAcpSessionMetaForMigration({ |
| databasePath, |
| sessionKey, |
| lifecycleRevision: "sess-existing", |
| now: () => 100, |
| meta: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-legacy", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }, |
| }); |
|
|
| expect(readAcpSessionEntry({ cfg, databasePath, sessionKey })?.acp?.runtimeSessionName).toBe( |
| "codex-legacy", |
| ); |
| expect(await listAcpSessionEntries({ cfg, databasePath })).toHaveLength(1); |
| expect( |
| readAcpSessionMetaForEntry({ |
| databasePath, |
| sessionKey, |
| entry: { |
| sessionId: "sess-existing", |
| lifecycleRevision: "revision-next", |
| sessionStartedAt: 150, |
| }, |
| }), |
| ).toBeUndefined(); |
|
|
| const staleKey = `${sessionKey}:stale`; |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey: staleKey, |
| entry: { |
| sessionId: "sess-stale", |
| lifecycleRevision: "revision-after-reset", |
| sessionStartedAt: 150, |
| updatedAt: 150, |
| }, |
| }); |
| writeAcpSessionMetaForMigration({ |
| databasePath, |
| sessionKey: staleKey, |
| lifecycleRevision: "sess-stale", |
| now: () => 100, |
| meta: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-stale-legacy", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 100, |
| }, |
| }); |
| expect(readAcpSessionEntry({ cfg, databasePath, sessionKey: staleKey })?.acp).toBeUndefined(); |
| }); |
| }); |
|
|
| it("keeps a session-id fence when ACP metadata is written before a lifecycle revision", async () => { |
| await withTestDir({ prefix: "openclaw-acp-meta-" }, async (dir) => { |
| const databasePath = path.join(dir, "state", "openclaw.sqlite"); |
| const sessionKey = "agent:codex:acp:pre-revision"; |
| writeAcpSessionMetaForMigration({ |
| databasePath, |
| sessionKey, |
| sessionId: "sess-pre-revision", |
| now: () => 100, |
| meta: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-pre-revision", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 100, |
| }, |
| }); |
|
|
| expect( |
| readAcpSessionMetaForEntry({ |
| databasePath, |
| sessionKey, |
| entry: { |
| sessionId: "sess-pre-revision", |
| lifecycleRevision: undefined, |
| sessionStartedAt: 50, |
| }, |
| })?.runtimeSessionName, |
| ).toBe("codex-pre-revision"); |
| expect( |
| readAcpSessionMetaForEntry({ |
| databasePath, |
| sessionKey, |
| entry: { |
| sessionId: "sess-pre-revision", |
| lifecycleRevision: "revision-after-reset", |
| sessionStartedAt: 150, |
| }, |
| }), |
| ).toBeUndefined(); |
| }); |
| }); |
|
|
| it("repairs ACP metadata rows when session-store keys are canonicalized", async () => { |
| await withTestDir({ 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 seedAcpSessionEntry({ |
| storePath, |
| sessionKey: canonicalKey, |
| entry: { |
| sessionId: "sess-acp", |
| lifecycleRevision: "revision-acp", |
| updatedAt: 100, |
| }, |
| }); |
| writeAcpSessionMetaForMigration({ |
| databasePath, |
| sessionKey: legacyKey, |
| lifecycleRevision: "revision-acp", |
| meta: { |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: legacyKey, |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 123, |
| }, |
| }); |
|
|
| expect( |
| repairAcpSessionMetaKeyForMigration({ |
| databasePath, |
| sessionKey: canonicalKey, |
| entry: { lifecycleRevision: "revision-acp" }, |
| now: () => 200, |
| }), |
| ).toBe(true); |
|
|
| expect( |
| readAcpSessionMetaForEntry({ |
| databasePath, |
| sessionKey: legacyKey, |
| entry: { lifecycleRevision: "revision-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 withTestDir({ 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 sessionKey = "agent:codex:acp:s1"; |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey, |
| entry: { |
| sessionId: "sess-acp", |
| updatedAt: 100, |
| model: "gpt-5.5", |
| }, |
| }); |
| await upsertAcpSessionMeta({ |
| cfg, |
| databasePath, |
| sessionKey, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-s1", |
| mode: "oneshot", |
| state: "running", |
| lastActivityAt: 321, |
| }), |
| }); |
|
|
| const entries = await listAcpSessionEntries({ cfg, databasePath, clone: false }); |
|
|
| expect(entries).toHaveLength(1); |
| expect(entries[0]).toMatchObject({ |
| cfg, |
| storePath, |
| sessionKey, |
| storeSessionKey: sessionKey, |
| entry: { |
| sessionId: "sess-acp", |
| model: "gpt-5.5", |
| }, |
| acp: { |
| backend: "acpx", |
| runtimeSessionName: "codex-s1", |
| mode: "oneshot", |
| state: "running", |
| }, |
| }); |
| }); |
| }); |
|
|
| it("honors OPENCLAW_STATE_DIR when joining listed SQLite rows to session stores", async () => { |
| await withTestDir({ prefix: "openclaw-acp-meta-" }, async (dir) => { |
| const env = { ...process.env, OPENCLAW_STATE_DIR: dir } as NodeJS.ProcessEnv; |
| const cfg = {} as OpenClawConfig; |
| const sessionKey = "agent:codex:acp:s1"; |
| const storePath = path.join(dir, "agents", "codex", "sessions", "sessions.json"); |
| await seedAcpSessionEntry({ |
| storePath, |
| sessionKey, |
| entry: { |
| sessionId: "sess-acp", |
| updatedAt: 100, |
| }, |
| }); |
| await upsertAcpSessionMeta({ |
| cfg, |
| env, |
| sessionKey, |
| mutate: () => ({ |
| backend: "acpx", |
| agent: "codex", |
| runtimeSessionName: "codex-s1", |
| mode: "persistent", |
| state: "idle", |
| lastActivityAt: 321, |
| }), |
| }); |
|
|
| const entries = await listAcpSessionEntries({ cfg, env }); |
|
|
| expect(entries).toHaveLength(1); |
| expect(entries[0]?.storePath).toBe(storePath); |
| expect(entries[0]?.entry?.sessionId).toBe("sess-acp"); |
| }); |
| }); |
| }); |
|
|
