| import { link, readFile, rm, writeFile } from "node:fs/promises"; |
| import { join } from "node:path"; |
| import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; |
| import { useAutoCleanupTempDirTracker } from "../../test/helpers/temp-dir.js"; |
| import { loadConfig } from "../config/config.js"; |
| import type { OpenClawConfig } from "../config/types.openclaw.js"; |
| import { cronJobReadView } from "../cron/job-read-view.js"; |
| import { normalizeCronJobCreate } from "../cron/normalize.js"; |
| import { upsertCronJobRow } from "../cron/store/row-codec.js"; |
| import type { CronStoredJob } from "../cron/types.js"; |
| import { readAgentDeletionJournal } from "../state/agent-deletion-journal.js"; |
| import { |
| listOpenClawRegisteredAgentDatabases, |
| registerOpenClawAgentDatabase, |
| } from "../state/openclaw-agent-db-registry.js"; |
| import { |
| closeOpenClawStateDatabaseForTest, |
| openOpenClawStateDatabase, |
| } from "../state/openclaw-state-db.js"; |
| import { |
| createOpenClawTestState, |
| type OpenClawTestState, |
| } from "../test-utils/openclaw-test-state.js"; |
| import { clawCronGatewayInput, markClawCronRefRemoved, readClawCronRefs } from "./cron.js"; |
| import { withClawAgentConfigRemoval } from "./lifecycle-config-removal.js"; |
| import { quiescentClawMonitorGateway } from "./lifecycle-remove.test-support.js"; |
| import { applyClawRemovePlan, buildClawRemovePlan, readClawStatus } from "./lifecycle-state.js"; |
| import { createClawRemoveTestFixtures } from "./lifecycle-state.test-helpers.js"; |
| import { |
| persistClawInstallRecord, |
| persistClawPackageRef, |
| readClawPackageRefs, |
| } from "./provenance.js"; |
|
|
| let state: OpenClawTestState; |
| beforeEach(async () => { |
| state = await createOpenClawTestState({ prefix: "claw-remove-config-" }); |
| await state.writeConfig({}); |
| }); |
| afterEach(async () => { |
| closeOpenClawStateDatabaseForTest(); |
| await state.cleanup(); |
| }); |
| const tempDirs = useAutoCleanupTempDirTracker(afterEach); |
| const { fixture, addFixture } = createClawRemoveTestFixtures(tempDirs, () => state); |
|
|
| const packageIntegrity = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; |
|
|
| function cronReadView(agentId: string, ref: ReturnType<typeof readClawCronRefs>[number]) { |
| const normalized = normalizeCronJobCreate(clawCronGatewayInput(agentId, ref)); |
| if (!normalized || !ref.schedulerJobId) { |
| throw new Error("expected complete cron provenance"); |
| } |
| return cronJobReadView({ |
| ...normalized, |
| id: ref.schedulerJobId, |
| createdAtMs: 1, |
| updatedAtMs: 1, |
| state: { nextRunAtMs: 100, lastRunAtMs: 50, lastStatus: "ok" }, |
| }); |
| } |
|
|
| function seedAttachedCronJob( |
| env: NodeJS.ProcessEnv, |
| job: Pick<CronStoredJob, "id" | "name" | "schedule">, |
| ): void { |
| const database = openOpenClawStateDatabase({ env }); |
| upsertCronJobRow( |
| database.db, |
| "default", |
| { |
| ...job, |
| agentId: "worker", |
| owner: { agentId: "worker" }, |
| enabled: true, |
| createdAtMs: 1, |
| updatedAtMs: 1, |
| sessionTarget: "isolated", |
| wakeMode: "now", |
| payload: { kind: "agentTurn", message: "Run scheduled job" }, |
| state: {}, |
| }, |
| 0, |
| ); |
| } |
|
|
| describe("Claw status and remove", () => { |
| it("previews locally without probing Gateway when there are no attached jobs, but never applies without one", async () => { |
| const current = await addFixture({ withFile: true }); |
| const inspect = vi.fn(async () => { |
| throw new Error("Gateway offline"); |
| }); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| monitorGateway: { ...quiescentClawMonitorGateway, inspect }, |
| }); |
| expect(plan.blockers).toEqual([]); |
| expect(inspect).not.toHaveBeenCalled(); |
| await expect( |
| applyClawRemovePlan(plan, { |
| env: current.env, |
| config: current.getConfig(), |
| consentPlanIntegrity: plan.planIntegrity, |
| }), |
| ).rejects.toMatchObject({ code: "monitor_gateway_required" }); |
| await expect(readFile(join(current.plan.agent.workspace, "SOUL.md"), "utf8")).resolves.toBe( |
| "managed\n", |
| ); |
| }); |
|
|
| it("rejects cleanup when an expected-missing agent id was recreated", async () => { |
| await expect( |
| withClawAgentConfigRemoval( |
| { |
| agentId: "worker", |
| expectedDigest: "sha256:missing", |
| expectedRemovalSurfaceDigest: "sha256:unused", |
| expectedState: "missing", |
| fallbackWorkspace: "/tmp/old-worker", |
| config: { agents: { entries: { worker: { workspace: "/tmp/new-worker" } } } }, |
| onModified: () => new Error("agent recreated"), |
| }, |
| (commitRemoval) => commitRemoval(), |
| ), |
| ).rejects.toThrow("agent recreated"); |
| }); |
|
|
| it("reports installed agent, managed files, and package references", async () => { |
| const current = await addFixture({ withFile: true }); |
| persistClawPackageRef( |
| current.plan, |
| { |
| kind: "plugin", |
| source: "clawhub", |
| ref: "audit", |
| version: "2.0.0", |
| integrity: packageIntegrity, |
| }, |
| { env: current.env, nowMs: 2 }, |
| ); |
| const status = await readClawStatus("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| expect(status).toMatchObject({ |
| summary: { |
| claws: 1, |
| partial: 0, |
| missingAgents: 0, |
| driftedFiles: 0, |
| packageRefs: 1, |
| missingPackages: 1, |
| }, |
| records: [ |
| { |
| install: { agentId: "worker", claw: { name: "@acme/worker" } }, |
| agentState: "present", |
| workspaceFiles: [{ path: "SOUL.md", state: "unchanged" }], |
| packages: [{ kind: "plugin", ref: "audit", state: "missing" }], |
| }, |
| ], |
| }); |
| }); |
|
|
| it("reports adapter identity drift for an installed extension without mutating provenance", async () => { |
| const current = await addFixture(); |
| const extension = { |
| id: "audit-tools", |
| format: "claude" as const, |
| detectedFormat: "claude" as const, |
| mapped: ["skills"], |
| unavailable: ["agents"], |
| adapterIdentity: "openclaw/previous", |
| }; |
| persistClawPackageRef( |
| current.plan, |
| { |
| kind: "plugin", |
| source: "clawhub", |
| ref: "audit", |
| version: "2.0.0", |
| integrity: packageIntegrity, |
| extension, |
| }, |
| { env: current.env, nowMs: 2, relationship: "referenced" }, |
| ); |
|
|
| const status = await readClawStatus("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| packageDeps: { |
| resolvePlugin: async () => ({ |
| status: "found" as const, |
| pluginId: "audit", |
| installedVersion: "2.0.0", |
| record: { source: "clawhub", integrity: packageIntegrity }, |
| }), |
| }, |
| }); |
|
|
| expect(status.summary.driftedPackages).toBe(1); |
| expect(status.records[0]?.packages[0]).toMatchObject({ |
| state: "present", |
| extension, |
| extensionCompatibility: { |
| state: "drifted", |
| mapped: ["agents", "skills"], |
| unavailable: [], |
| adapterIdentity: "openclaw/v1", |
| }, |
| }); |
| expect(readClawPackageRefs({ env: current.env })[0]?.extension).toEqual(extension); |
| }); |
|
|
| it("reports unavailable extension inspection separately from package drift", async () => { |
| const current = await addFixture(); |
| const extension = { |
| id: "audit-tools", |
| format: "claude" as const, |
| detectedFormat: "claude" as const, |
| mapped: ["skills"], |
| unavailable: ["agents"], |
| adapterIdentity: "openclaw/current", |
| }; |
| persistClawPackageRef( |
| current.plan, |
| { |
| kind: "plugin", |
| source: "clawhub", |
| ref: "audit", |
| version: "2.0.0", |
| integrity: packageIntegrity, |
| extension, |
| }, |
| { env: current.env, nowMs: 2, relationship: "referenced" }, |
| ); |
|
|
| const status = await readClawStatus("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| packageDeps: { |
| resolvePlugin: async () => ({ |
| status: "found" as const, |
| pluginId: "audit", |
| installedVersion: "2.0.0", |
| record: { source: "clawhub", integrity: packageIntegrity }, |
| }), |
| }, |
| packagePreflight: async () => ({ |
| ok: false, |
| code: "extension_unavailable", |
| message: "Canonical extension inspection is unavailable.", |
| }), |
| }); |
|
|
| expect(status.summary).toMatchObject({ driftedPackages: 0, unavailableExtensions: 1 }); |
| expect(status.records[0]?.packages[0]).toMatchObject({ |
| state: "present", |
| extensionCompatibility: { |
| state: "unavailable", |
| message: "Canonical extension inspection is unavailable.", |
| }, |
| }); |
| }); |
|
|
| it("counts every non-complete root install as partial", async () => { |
| const current = await fixture(); |
| persistClawInstallRecord(current.plan, { env: current.env, status: "config_committed" }); |
|
|
| await expect( |
| readClawStatus("worker", { env: current.env, config: { agents: { entries: {} } } }), |
| ).resolves.toMatchObject({ summary: { claws: 1, partial: 1 } }); |
| }); |
|
|
| it("reports orphaned subordinate ownership without a root install row", async () => { |
| const current = await fixture(); |
| persistClawPackageRef( |
| current.plan, |
| { |
| kind: "plugin", |
| source: "clawhub", |
| ref: "audit", |
| version: "2.0.0", |
| integrity: packageIntegrity, |
| }, |
| { env: current.env, nowMs: 2 }, |
| ); |
|
|
| await expect(readClawStatus("worker", { env: current.env, config: {} })).resolves.toMatchObject( |
| { |
| summary: { claws: 1, partial: 1, missingAgents: 1, packageRefs: 1 }, |
| records: [ |
| { |
| orphaned: true, |
| install: { agentId: "worker", status: "partial" }, |
| packages: [{ ref: "audit", state: "missing" }], |
| }, |
| ], |
| }, |
| ); |
|
|
| const remove = await buildClawRemovePlan("worker", { env: current.env, config: {} }); |
| const removed = await applyClawRemovePlan(remove, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| env: current.env, |
| config: {}, |
| consentPlanIntegrity: remove.planIntegrity, |
| purgeSessions: async () => undefined, |
| }); |
| expect(removed).toMatchObject({ status: "complete", agentRemoved: false }); |
| await expect(readClawStatus("worker", { env: current.env, config: {} })).resolves.toMatchObject( |
| { |
| summary: { claws: 0 }, |
| }, |
| ); |
| }); |
|
|
| it("previews all canonical agent config deletion effects", async () => { |
| const current = await addFixture(); |
| const config: OpenClawConfig = { |
| ...current.getConfig(), |
| bindings: [{ match: { channel: "telegram", accountId: "*" }, agentId: "worker" }], |
| tools: { agentToAgent: { allow: ["worker"] } }, |
| } as OpenClawConfig; |
|
|
| const plan = await buildClawRemovePlan("worker", { env: current.env, config }); |
|
|
| expect(plan.actions).toEqual( |
| expect.arrayContaining([ |
| expect.objectContaining({ kind: "agent", target: 'agents.entries["worker"]' }), |
| expect.objectContaining({ kind: "configBinding", target: "bindings[agentId=worker]" }), |
| expect.objectContaining({ kind: "agentAllow", target: "tools.agentToAgent.allow[worker]" }), |
| expect.objectContaining({ kind: "workspace", action: "trash" }), |
| expect.objectContaining({ kind: "agentState", action: "trash" }), |
| expect.objectContaining({ kind: "sessionIndex", action: "delete" }), |
| expect.objectContaining({ kind: "sessionTranscripts", action: "trash" }), |
| ]), |
| ); |
| }); |
|
|
| it("refuses changed bindings and retains the cleanup fence", async () => { |
| const current = await addFixture(); |
| const config: OpenClawConfig = { |
| ...current.getConfig(), |
| bindings: [{ match: { channel: "telegram", accountId: "first" }, agentId: "worker" }], |
| } as OpenClawConfig; |
| const plan = await buildClawRemovePlan("worker", { env: current.env, config }); |
| const changedConfig: OpenClawConfig = { |
| ...config, |
| bindings: [{ match: { channel: "telegram", accountId: "second" }, agentId: "worker" }], |
| } as OpenClawConfig; |
|
|
| await expect( |
| applyClawRemovePlan(plan, { |
| monitorGateway: { |
| ...quiescentClawMonitorGateway, |
| quiesce: async () => { |
| await state.writeConfig(changedConfig); |
| }, |
| }, |
| env: current.env, |
| config, |
| consentPlanIntegrity: plan.planIntegrity, |
| }), |
| ).resolves.toMatchObject({ |
| status: "partial", |
| agentRemoved: false, |
| error: { code: "agent_modified" }, |
| }); |
| expect(readAgentDeletionJournal("worker", { env: current.env })).toMatchObject({ |
| cleanupCompleted: false, |
| }); |
| }); |
|
|
| it("previews and blocks operator-owned cron jobs attached to the agent", async () => { |
| const current = await addFixture(); |
| seedAttachedCronJob(current.env, { |
| id: "operator-job", |
| name: "Operator job", |
| schedule: { kind: "every", everyMs: 60_000 }, |
| }); |
|
|
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
|
|
| expect(plan.blockers).toContainEqual(expect.objectContaining({ code: "agent_job_attached" })); |
| expect(plan.actions).toContainEqual( |
| expect.objectContaining({ |
| kind: "scheduledJob", |
| id: "operator-job", |
| action: "retain", |
| blocked: true, |
| }), |
| ); |
| }); |
|
|
| it.each([false, true])( |
| "keeps Claw-owned cron removal actions consistent (independent jobs=%s)", |
| async (withIndependentJobs) => { |
| const current = await addFixture({ withCron: true }); |
| seedAttachedCronJob(current.env, { |
| id: "scheduler-daily", |
| name: "Claw job", |
| schedule: { kind: "cron", expr: "0 9 * * *", tz: "UTC" }, |
| }); |
| if (withIndependentJobs) { |
| for (const id of ["z-operator-job", "a-operator-job"]) { |
| seedAttachedCronJob(current.env, { |
| id, |
| name: "Operator job", |
| schedule: { kind: "every", everyMs: 60_000 }, |
| }); |
| } |
| } |
|
|
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| const independentIds = withIndependentJobs ? ["a-operator-job", "z-operator-job"] : []; |
| expect(plan.blockers).toEqual( |
| independentIds.map((id) => ({ |
| code: "agent_job_attached", |
| message: expect.stringContaining(JSON.stringify(id)), |
| })), |
| ); |
| expect(plan.actions.filter((action) => action.kind === "scheduledJob")).toEqual( |
| independentIds.map((id) => |
| expect.objectContaining({ id, action: "retain", blocked: true }), |
| ), |
| ); |
| expect(plan.actions.filter((action) => action.kind === "cronJob")).toEqual([ |
| expect.objectContaining({ |
| id: "daily-report", |
| target: "scheduler-daily", |
| action: "remove", |
| blocked: false, |
| }), |
| ]); |
| }, |
| ); |
|
|
| it("removes the agent and unchanged files but only releases package refs", async () => { |
| const current = await addFixture({ withFile: true }); |
| const databasePath = join( |
| current.env.OPENCLAW_STATE_DIR, |
| "agents", |
| "worker", |
| "agent", |
| "openclaw-agent.sqlite", |
| ); |
| registerOpenClawAgentDatabase({ agentId: "worker", path: databasePath, env: current.env }); |
| persistClawPackageRef( |
| current.plan, |
| { |
| kind: "skill", |
| source: "clawhub", |
| ref: "triage", |
| version: "1.0.0", |
| integrity: packageIntegrity, |
| }, |
| { env: current.env }, |
| ); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| const config = current.getConfig(); |
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config, |
| }); |
| expect(result).toMatchObject({ |
| status: "complete", |
| agentRemoved: true, |
| packageRefsReleased: 1, |
| workspaceFiles: [{ path: "SOUL.md", action: "deleted" }], |
| }); |
| expect(loadConfig().agents?.entries?.worker).toBeUndefined(); |
| expect( |
| listOpenClawRegisteredAgentDatabases({ env: current.env }).map((entry) => entry.agentId), |
| ).not.toContain("worker"); |
| await expect(readFile(join(current.plan.agent.workspace, "SOUL.md"), "utf8")).rejects.toThrow(); |
| await expect( |
| readClawStatus("worker", { env: current.env, config: loadConfig() }), |
| ).resolves.toMatchObject({ |
| summary: { claws: 0 }, |
| }); |
| }); |
|
|
| it("removes scheduler-owned cron jobs before agent config", async () => { |
| const current = await addFixture({ withCron: true }); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| expect(plan.actions).toContainEqual( |
| expect.objectContaining({ |
| kind: "cronJob", |
| id: "daily-report", |
| action: "remove", |
| target: "scheduler-daily", |
| }), |
| ); |
| const config = current.getConfig(); |
| const order: string[] = []; |
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config, |
| cronGateway: { |
| get: async () => |
| cronReadView("worker", readClawCronRefs("worker", { env: current.env })[0]!), |
| remove: async (id) => { |
| expect(loadConfig().agents?.entries?.worker).toBeDefined(); |
| order.push(`cron:${id}`); |
| return { ok: true }; |
| }, |
| }, |
| }); |
| expect(order).toEqual(["cron:scheduler-daily"]); |
| expect(loadConfig().agents?.entries?.worker).toBeUndefined(); |
| expect(result).toMatchObject({ |
| status: "complete", |
| cronJobs: [ |
| { manifestId: "daily-report", schedulerJobId: "scheduler-daily", action: "removed" }, |
| ], |
| }); |
| }); |
|
|
| it("accepts scheduler defaults when removing a Claw cron job", async () => { |
| const current = await addFixture({ withCron: true }); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| const ref = readClawCronRefs("worker", { env: current.env })[0]!; |
| const live = cronReadView("worker", ref); |
| const remove = vi.fn().mockResolvedValue({ ok: true }); |
|
|
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config: current.getConfig(), |
| cronGateway: { |
| get: async () => ({ |
| ...live, |
| payload: { ...live.payload, toolsAllow: ["*"] }, |
| scheduledToolPolicy: { version: 1, mode: "trusted" }, |
| }), |
| remove, |
| }, |
| }); |
|
|
| expect(remove).toHaveBeenCalledWith(ref.schedulerJobId); |
| expect(result).toMatchObject({ |
| status: "complete", |
| agentRemoved: true, |
| cronJobs: [{ manifestId: "daily-report", action: "removed" }], |
| }); |
| }); |
|
|
| it("fails removal planning when source MCP config cannot be read", async () => { |
| const current = await addFixture({ withCron: true }); |
|
|
| await expect( |
| buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| listMcpServers: async () => ({ |
| ok: false, |
| path: "config", |
| error: "Config file is invalid.", |
| }), |
| }), |
| ).rejects.toMatchObject({ code: "mcp_config_unavailable" }); |
| }); |
|
|
| it("retains the agent when recurring work cannot be disabled", async () => { |
| const current = await addFixture({ withCron: true }); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config: current.getConfig(), |
| cronGateway: { |
| get: async () => |
| cronReadView("worker", readClawCronRefs("worker", { env: current.env })[0]!), |
| remove: async () => { |
| throw new Error("scheduler unavailable"); |
| }, |
| }, |
| }); |
|
|
| expect(result).toMatchObject({ |
| status: "partial", |
| agentRemoved: false, |
| error: { code: "cron_cleanup_failed", message: "scheduler unavailable" }, |
| cronJobs: [{ manifestId: "daily-report", action: "error" }], |
| }); |
| }); |
|
|
| it("reconciles a lost cron.remove response when the gateway confirms absence", async () => { |
| const current = await addFixture({ withCron: true }); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| const ref = readClawCronRefs("worker", { env: current.env })[0]!; |
| let present = true; |
| const config = current.getConfig(); |
|
|
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config, |
| cronGateway: { |
| get: async () => (present ? cronReadView("worker", ref) : undefined), |
| remove: async () => { |
| present = false; |
| throw new Error("response lost"); |
| }, |
| }, |
| }); |
|
|
| expect(result).toMatchObject({ |
| status: "complete", |
| cronJobs: [{ manifestId: "daily-report", action: "removed" }], |
| }); |
| }); |
|
|
| it("preserves a live cron job that changed after planning", async () => { |
| const current = await addFixture({ withCron: true }); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| const remove = vi.fn(); |
|
|
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config: current.getConfig(), |
| cronGateway: { |
| get: async () => ({ |
| ...cronReadView("worker", readClawCronRefs("worker", { env: current.env })[0]!), |
| schedule: { kind: "cron", expr: "0 12 * * *", tz: "UTC" }, |
| }), |
| remove, |
| }, |
| }); |
|
|
| expect(result).toMatchObject({ |
| status: "partial", |
| agentRemoved: false, |
| error: { code: "cron_cleanup_failed", message: expect.stringContaining("changed") }, |
| }); |
| expect(remove).not.toHaveBeenCalled(); |
| }); |
|
|
| it("finishes local cleanup without repeating a confirmed remote cron removal", async () => { |
| const current = await addFixture({ withCron: true }); |
| markClawCronRefRemoved("worker", "daily-report", { env: current.env }); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| const config = current.getConfig(); |
| const remoteRemovals: string[] = []; |
|
|
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config, |
| cronGateway: { |
| remove: async (id) => { |
| remoteRemovals.push(id); |
| return { ok: true }; |
| }, |
| }, |
| }); |
|
|
| expect(remoteRemovals).toEqual([]); |
| expect(result).toMatchObject({ |
| status: "complete", |
| cronJobs: [{ manifestId: "daily-report", action: "removed" }], |
| }); |
| }); |
|
|
| it("preserves modified files while releasing their provenance", async () => { |
| const current = await addFixture({ withFile: true }); |
| const target = join(current.plan.agent.workspace, "SOUL.md"); |
| await writeFile(target, "operator edit\n", "utf8"); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| expect(plan.actions).toContainEqual( |
| expect.objectContaining({ kind: "workspace", action: "retain" }), |
| ); |
| const trashPath = vi.fn().mockResolvedValue(true); |
| expect(plan.actions).toContainEqual( |
| expect.objectContaining({ kind: "workspaceFile", action: "retain", blocked: false }), |
| ); |
| const config = current.getConfig(); |
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config, |
| trashPath, |
| }); |
| expect(result.workspaceFiles).toEqual([{ path: "SOUL.md", action: "retainedModified" }]); |
| await expect(readFile(target, "utf8")).resolves.toBe("operator edit\n"); |
| expect(trashPath).not.toHaveBeenCalledWith(current.plan.agent.workspace, expect.anything()); |
| }); |
|
|
| it("preserves a workspace containing operator-created files", async () => { |
| const current = await addFixture({ withFile: true }); |
| const operatorFile = join(current.plan.agent.workspace, "operator-notes.md"); |
| await writeFile(operatorFile, "keep me\n", "utf8"); |
| const config = current.getConfig(); |
| const plan = await buildClawRemovePlan("worker", { env: current.env, config }); |
| expect(plan.actions).toContainEqual( |
| expect.objectContaining({ kind: "workspace", action: "retain" }), |
| ); |
| const trashPath = vi.fn().mockResolvedValue(true); |
|
|
| await expect( |
| applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| env: current.env, |
| config, |
| consentPlanIntegrity: plan.planIntegrity, |
| purgeSessions: async () => undefined, |
| trashPath, |
| }), |
| ).resolves.toMatchObject({ status: "complete" }); |
| await expect(readFile(operatorFile, "utf8")).resolves.toBe("keep me\n"); |
| expect(trashPath).not.toHaveBeenCalledWith(current.plan.agent.workspace, expect.anything()); |
| }); |
|
|
| it("retains a replacement introduced after planning instead of deleting it", async () => { |
| const current = await addFixture({ withFile: true }); |
| const target = join(current.plan.agent.workspace, "SOUL.md"); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| const config = current.getConfig(); |
|
|
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: { |
| ...quiescentClawMonitorGateway, |
| drain: async () => { |
| expect(loadConfig().agents?.entries?.worker).toBeUndefined(); |
| await writeFile(target, "replacement\n", "utf8"); |
| }, |
| }, |
| trashPath: async () => true, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config, |
| }); |
|
|
| expect(result).toMatchObject({ |
| status: "complete", |
| workspaceFiles: [{ path: "SOUL.md", action: "retainedModified" }], |
| }); |
| await expect(readFile(target, "utf8")).resolves.toBe("replacement\n"); |
| }); |
| it("keeps the install ledger when workspace cleanup becomes unsafe after config commit", async () => { |
| const current = await addFixture({ withFile: true }); |
| const target = join(current.plan.agent.workspace, "SOUL.md"); |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config: current.getConfig(), |
| }); |
| const config = current.getConfig(); |
|
|
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: { |
| ...quiescentClawMonitorGateway, |
| drain: async () => { |
| expect(loadConfig().agents?.entries?.worker).toBeUndefined(); |
| await rm(target); |
| await link(join(current.root, "SOUL.md"), target); |
| }, |
| }, |
| trashPath: async () => true, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config, |
| }); |
|
|
| expect(result).toMatchObject({ |
| status: "partial", |
| agentRemoved: true, |
| workspaceFiles: [{ path: "SOUL.md", action: "error" }], |
| error: { code: "workspace_cleanup_failed" }, |
| }); |
| await expect( |
| readClawStatus("worker", { env: current.env, config: loadConfig() }), |
| ).resolves.toMatchObject({ |
| summary: { claws: 1, missingAgents: 1 }, |
| records: [{ install: { status: "partial" }, workspaceFiles: [{ state: "unsafe" }] }], |
| }); |
| }); |
|
|
| it("purges session indexes and keeps provenance when canonical trash cleanup fails", async () => { |
| const current = await addFixture(); |
| const config = current.getConfig(); |
| const plan = await buildClawRemovePlan("worker", { env: current.env, config }); |
| let purgedAgentId: string | undefined; |
|
|
| const result = await applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| consentPlanIntegrity: plan.planIntegrity, |
| env: current.env, |
| config, |
| purgeSessions: async (_cfg, agentId) => { |
| purgedAgentId = agentId; |
| }, |
| trashPath: async () => false, |
| }); |
|
|
| expect(purgedAgentId).toBe("worker"); |
| expect(result).toMatchObject({ |
| status: "partial", |
| agentRemoved: true, |
| error: { code: "workspace_cleanup_failed" }, |
| }); |
| await expect( |
| readClawStatus("worker", { env: current.env, config: loadConfig() }), |
| ).resolves.toMatchObject({ records: [{ install: { status: "partial" } }] }); |
| }); |
|
|
| it("releases global plugin references without uninstalling the plugin", async () => { |
| const current = await addFixture(); |
| persistClawPackageRef( |
| current.plan, |
| { |
| kind: "plugin", |
| source: "clawhub", |
| ref: "audit", |
| version: "1.0.0", |
| integrity: packageIntegrity, |
| }, |
| { |
| env: current.env, |
| relationship: "referenced", |
| origin: "claw-introduced", |
| independentOwner: false, |
| }, |
| ); |
| const config = current.getConfig(); |
| const resolvePlugin = vi.fn().mockResolvedValue({ |
| status: "found", |
| pluginId: "audit", |
| record: { source: "clawhub", integrity: packageIntegrity }, |
| installedVersion: "1.0.0", |
| }); |
| const packageDeps = { |
| resolvePlugin, |
| acquirePackageLease: vi.fn(() => ({ heartbeat: vi.fn(), release: vi.fn() })), |
| }; |
| const plan = await buildClawRemovePlan("worker", { |
| env: current.env, |
| config, |
| packageDeps, |
| }); |
| expect(plan.actions).toContainEqual( |
| expect.objectContaining({ |
| kind: "packageRef", |
| action: "release", |
| reason: expect.stringContaining("Claw add introduced this shared requirement"), |
| details: expect.objectContaining({ introducedByClawAdd: true }), |
| }), |
| ); |
|
|
| await expect( |
| applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| env: current.env, |
| config, |
| consentPlanIntegrity: plan.planIntegrity, |
| packageDeps, |
| }), |
| ).resolves.toMatchObject({ status: "complete", agentRemoved: true }); |
| }); |
|
|
| it("blocks removal when the created agent config changed", async () => { |
| const current = await addFixture(); |
| const config = current.getConfig(); |
| const agent = config.agents!.entries!.worker!; |
| config.agents!.entries!.worker = { ...agent, name: "Operator edit" }; |
| const plan = await buildClawRemovePlan("worker", { env: current.env, config }); |
| expect(plan.blockers).toContainEqual(expect.objectContaining({ code: "agent_modified" })); |
| await expect( |
| applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| env: current.env, |
| config, |
| consentPlanIntegrity: plan.planIntegrity, |
| }), |
| ).rejects.toMatchObject({ |
| code: "remove_blocked", |
| }); |
| }); |
|
|
| it("rejects removal consent for a different plan identity", async () => { |
| const current = await addFixture(); |
| const config = current.getConfig(); |
| const plan = await buildClawRemovePlan("worker", { env: current.env, config }); |
|
|
| await expect( |
| applyClawRemovePlan(plan, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| env: current.env, |
| config, |
| consentPlanIntegrity: "sha256:stale", |
| }), |
| ).rejects.toMatchObject({ code: "plan_integrity_mismatch" }); |
| }); |
|
|
| it("requires an agent id when a package identity has multiple installs", async () => { |
| const first = await fixture({ id: "worker-a", name: "@acme/shared" }); |
| const second = await fixture({ id: "worker-b", name: "@acme/shared" }); |
| persistClawInstallRecord(first.plan, { env: first.env }); |
| persistClawInstallRecord(second.plan, { env: first.env }); |
| const plan = await buildClawRemovePlan("@acme/shared", { env: first.env, config: {} }); |
| expect(plan.blockers).toContainEqual(expect.objectContaining({ code: "claw_ambiguous" })); |
| }); |
|
|
| it("keeps Claw-introduced plugin origin on every surviving Claw reference", async () => { |
| const first = await fixture({ id: "worker-a", name: "@acme/first" }); |
| const second = await fixture({ id: "worker-b", name: "@acme/second" }); |
| persistClawInstallRecord(first.plan, { env: first.env, nowMs: 1 }); |
| persistClawInstallRecord(second.plan, { env: first.env, nowMs: 2 }); |
| const plugin = { |
| kind: "plugin", |
| source: "clawhub", |
| ref: "audit", |
| version: "1.0.0", |
| integrity: packageIntegrity, |
| } as const; |
| persistClawPackageRef(first.plan, plugin, { |
| env: first.env, |
| nowMs: 1, |
| relationship: "referenced", |
| origin: "claw-introduced", |
| independentOwner: false, |
| }); |
| persistClawPackageRef(second.plan, plugin, { |
| env: first.env, |
| nowMs: 2, |
| relationship: "referenced", |
| origin: "claw-introduced", |
| independentOwner: false, |
| }); |
| const { id: firstId, ...firstConfig } = first.plan.agent.config; |
| const { id: secondId, ...secondConfig } = second.plan.agent.config; |
| const config: OpenClawConfig = { |
| agents: { entries: { [firstId]: firstConfig, [secondId]: secondConfig } }, |
| }; |
| await state.writeConfig(config); |
| const remove = await buildClawRemovePlan("worker-a", { env: first.env, config }); |
| await applyClawRemovePlan(remove, { |
| monitorGateway: quiescentClawMonitorGateway, |
| trashPath: async () => true, |
| consentPlanIntegrity: remove.planIntegrity, |
| env: first.env, |
| config, |
| }); |
|
|
| expect(readClawPackageRefs({ env: first.env, agentId: "worker-b" })).toMatchObject([ |
| { |
| ref: "audit", |
| relationship: "referenced", |
| origin: "claw-introduced", |
| independentOwner: false, |
| }, |
| ]); |
| }); |
| }); |
|
|
