@hyperdrive.bot/fleet-server 0.3.159 → 0.3.160

package/dist/server/server/schedule/store.d.ts

@@ -1,13 +1,64 @@
 import { type StoredSchedule } from "@hyperdrive.bot/fleet-protocol/schedule/types";
+/**
+ * How many runs a schedule file keeps. Every run start and finish rewrites the
+ * whole file, and the history grew unbounded (5,510 runs, 2.3 MB in one real
+ * file), so the oldest runs are dropped at write time. How many finished runs
+ * were dropped is kept in `droppedRunCount`, so `maxRuns` completion still
+ * counts every run that ever happened.
+ */
+export declare const SCHEDULE_RUNS_RETAINED = 200;
+export declare function capScheduleRuns(schedule: StoredSchedule): StoredSchedule;
+/**
+ * Three-way merge of a daemon write over a file that changed on disk since the
+ * daemon last read it. `base` is what the daemon read, `mine` what it wants to
+ * write, `theirs` what is on disk now. A top-level field the daemon did not
+ * change keeps the disk value; a field it changed keeps the daemon's. Runs are
+ * unioned by id, the daemon's copy of a run winning.
+ */
+export declare function mergeScheduleWrite(base: StoredSchedule, mine: StoredSchedule, theirs: StoredSchedule): StoredSchedule;
+/**
+ * File-backed schedule store with an in-memory cache validated against disk.
+ *
+ * Every read stats the directory's `*.json` files (no read, no parse) and
+ * re-reads only files whose mtime or size changed, so a schedule written by
+ * hand or by another tool is still picked up by a running daemon, at a fraction
+ * of the cost of re-parsing 5 MB of JSON per call. Concurrent reads share one
+ * validation pass. A write whose file changed on disk since the daemon read it
+ * is merged over the disk copy (`mergeScheduleWrite`) rather than clobbering it.
+ *
+ * Returned objects are shared with the cache: treat them as read-only and write
+ * changes back through `put`.
+ */
 export declare class ScheduleStore {
     private readonly dir;
+    private readonly cache;
+    private readonly stamps;
+    private validating;
+    private revision;
     constructor(dir: string);
     private filePath;
     private ensureDir;
+    private readStamp;
+    private readScheduleFile;
+    /** Bring the cache in line with disk, re-reading only files that changed. */
+    private validate;
+    private validateNow;
     list(): Promise<StoredSchedule[]>;
     get(id: string): Promise<StoredSchedule | null>;
+    /**
+     * Delete temp files left by atomic writes that never renamed (a crash or kill
+     * mid-write). They are invisible to `list` but pile up on disk. Returns how
+     * many were removed.
+     */
+    sweepOrphanedTempFiles(now?: number): Promise<number>;
     create(schedule: Omit<StoredSchedule, "id">): Promise<StoredSchedule>;
     put(schedule: StoredSchedule): Promise<void>;
     delete(id: string): Promise<void>;
+    /**
+     * Bumps whenever the cached set changes (a disk change seen on validation, a
+     * put, a delete), so a caller can reuse anything it derived from `list()`
+     * until the store actually changes.
+     */
+    get version(): number;
 }
 //# sourceMappingURL=store.d.ts.map

package/dist/server/server/schedule/store.js

@@ -1,14 +1,84 @@
 import { randomBytes } from "node:crypto";
-import { mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { StoredScheduleSchema, } from "@hyperdrive.bot/fleet-protocol/schedule/types";
 import { writeJsonFileAtomic } from "../atomic-file.js";
+/**
+ * How many runs a schedule file keeps. Every run start and finish rewrites the
+ * whole file, and the history grew unbounded (5,510 runs, 2.3 MB in one real
+ * file), so the oldest runs are dropped at write time. How many finished runs
+ * were dropped is kept in `droppedRunCount`, so `maxRuns` completion still
+ * counts every run that ever happened.
+ */
+export const SCHEDULE_RUNS_RETAINED = 200;
+/**
+ * A leftover `.<id>.json.<pid>.<ts>.<uuid>.tmp` from an interrupted atomic write
+ * is only swept when it is at least this old, so a write racing the sweep is
+ * never deleted from under itself.
+ */
+const ORPHAN_TMP_MIN_AGE_MS = 60000;
+export function capScheduleRuns(schedule) {
+    if (schedule.runs.length <= SCHEDULE_RUNS_RETAINED) {
+        return schedule;
+    }
+    const dropped = schedule.runs.slice(0, schedule.runs.length - SCHEDULE_RUNS_RETAINED);
+    const droppedFinished = dropped.filter((run) => run.status !== "running").length;
+    return {
+        ...schedule,
+        runs: schedule.runs.slice(-SCHEDULE_RUNS_RETAINED),
+        droppedRunCount: (schedule.droppedRunCount ?? 0) + droppedFinished,
+    };
+}
+function sameStamp(left, right) {
+    return (left !== undefined &&
+        right !== undefined &&
+        left.mtimeMs === right.mtimeMs &&
+        left.size === right.size);
+}
+/**
+ * Three-way merge of a daemon write over a file that changed on disk since the
+ * daemon last read it. `base` is what the daemon read, `mine` what it wants to
+ * write, `theirs` what is on disk now. A top-level field the daemon did not
+ * change keeps the disk value; a field it changed keeps the daemon's. Runs are
+ * unioned by id, the daemon's copy of a run winning.
+ */
+export function mergeScheduleWrite(base, mine, theirs) {
+    const merged = { ...theirs };
+    for (const key of Object.keys(mine)) {
+        if (key === "runs")
+            continue;
+        if (JSON.stringify(mine[key]) !== JSON.stringify(base[key])) {
+            merged[key] = mine[key];
+        }
+    }
+    const mineRunIds = new Set(mine.runs.map((run) => run.id));
+    const theirsOnly = theirs.runs.filter((run) => !mineRunIds.has(run.id));
+    merged.runs = [...theirsOnly, ...mine.runs].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+    return merged;
+}
 function generateScheduleId() {
     return randomBytes(4).toString("hex");
 }
+/**
+ * File-backed schedule store with an in-memory cache validated against disk.
+ *
+ * Every read stats the directory's `*.json` files (no read, no parse) and
+ * re-reads only files whose mtime or size changed, so a schedule written by
+ * hand or by another tool is still picked up by a running daemon, at a fraction
+ * of the cost of re-parsing 5 MB of JSON per call. Concurrent reads share one
+ * validation pass. A write whose file changed on disk since the daemon read it
+ * is merged over the disk copy (`mergeScheduleWrite`) rather than clobbering it.
+ *
+ * Returned objects are shared with the cache: treat them as read-only and write
+ * changes back through `put`.
+ */
 export class ScheduleStore {
     constructor(dir) {
         this.dir = dir;
+        this.cache = new Map();
+        this.stamps = new Map();
+        this.validating = null;
+        this.revision = 0;
     }
     filePath(id) {
         return join(this.dir, `${id}.json`);
@@ -16,29 +86,99 @@ export class ScheduleStore {
     async ensureDir() {
         await mkdir(this.dir, { recursive: true });
     }
-    async list() {
+    async readStamp(path) {
+        try {
+            const info = await stat(path);
+            return { mtimeMs: info.mtimeMs, size: info.size };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    async readScheduleFile(path) {
+        const content = await readFile(path, "utf-8");
+        return StoredScheduleSchema.parse(JSON.parse(content));
+    }
+    /** Bring the cache in line with disk, re-reading only files that changed. */
+    validate() {
+        if (!this.validating) {
+            this.validating = this.validateNow().finally(() => {
+                this.validating = null;
+            });
+        }
+        return this.validating;
+    }
+    async validateNow() {
         await this.ensureDir();
         const entries = await readdir(this.dir, { withFileTypes: true });
-        const schedules = await Promise.all(entries
+        const names = entries
             .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
-            .map(async (entry) => {
-            const content = await readFile(join(this.dir, entry.name), "utf-8");
-            return StoredScheduleSchema.parse(JSON.parse(content));
+            .map((entry) => entry.name);
+        const seen = new Set();
+        let changed = false;
+        await Promise.all(names.map(async (name) => {
+            seen.add(name);
+            const path = join(this.dir, name);
+            const stamp = await this.readStamp(path);
+            if (!stamp)
+                return;
+            if (sameStamp(this.stamps.get(name), stamp))
+                return;
+            const schedule = await this.readScheduleFile(path);
+            this.cache.set(schedule.id, schedule);
+            this.stamps.set(name, stamp);
+            changed = true;
         }));
-        return schedules.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+        for (const name of this.stamps.keys()) {
+            if (seen.has(name))
+                continue;
+            this.stamps.delete(name);
+            this.cache.delete(name.slice(0, -".json".length));
+            changed = true;
+        }
+        if (changed) {
+            this.revision += 1;
+        }
+    }
+    async list() {
+        await this.validate();
+        return [...this.cache.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
     }
     async get(id) {
+        await this.validate();
+        return this.cache.get(id) ?? null;
+    }
+    /**
+     * Delete temp files left by atomic writes that never renamed (a crash or kill
+     * mid-write). They are invisible to `list` but pile up on disk. Returns how
+     * many were removed.
+     */
+    async sweepOrphanedTempFiles(now = Date.now()) {
         await this.ensureDir();
-        try {
-            const content = await readFile(this.filePath(id), "utf-8");
-            return StoredScheduleSchema.parse(JSON.parse(content));
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return null;
+        const entries = await readdir(this.dir, { withFileTypes: true });
+        let removed = 0;
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.startsWith(".") || !entry.name.endsWith(".tmp")) {
+                continue;
+            }
+            const path = join(this.dir, entry.name);
+            try {
+                const info = await stat(path);
+                if (now - info.mtimeMs < ORPHAN_TMP_MIN_AGE_MS) {
+                    continue;
+                }
+                await rm(path, { force: true });
+                removed += 1;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
             }
-            throw error;
         }
+        return removed;
     }
     async create(schedule) {
         const created = { ...schedule, id: generateScheduleId() };
@@ -47,11 +187,39 @@ export class ScheduleStore {
     }
     async put(schedule) {
         await this.ensureDir();
-        await writeJsonFileAtomic(this.filePath(schedule.id), schedule);
+        const name = `${schedule.id}.json`;
+        const path = this.filePath(schedule.id);
+        let next = schedule;
+        // What the daemon last read for this id, and the file stamp it read it at.
+        const base = this.cache.get(schedule.id);
+        const known = this.stamps.get(name);
+        const onDisk = known ? await this.readStamp(path) : undefined;
+        if (base && known && onDisk && !sameStamp(known, onDisk)) {
+            // Edited behind the daemon's back since it was read: merge, never clobber.
+            next = mergeScheduleWrite(base, schedule, await this.readScheduleFile(path));
+        }
+        const capped = capScheduleRuns(next);
+        await writeJsonFileAtomic(path, capped);
+        const stamp = await this.readStamp(path);
+        if (stamp)
+            this.stamps.set(name, stamp);
+        this.cache.set(capped.id, capped);
+        this.revision += 1;
     }
     async delete(id) {
         await this.ensureDir();
         await rm(this.filePath(id), { force: true });
+        this.cache.delete(id);
+        this.stamps.delete(`${id}.json`);
+        this.revision += 1;
+    }
+    /**
+     * Bumps whenever the cached set changes (a disk change seen on validation, a
+     * put, a delete), so a caller can reuse anything it derived from `list()`
+     * until the store actually changes.
+     */
+    get version() {
+        return this.revision;
     }
 }
 //# sourceMappingURL=store.js.map

package/dist/server/server/session/agent-updates/agent-updates-service.d.ts

@@ -30,7 +30,14 @@ export interface AgentUpdatesService {
     }): void;
     clearSubscription(subscriptionId: string): void;
     hasSubscription(): boolean;
-    forwardLiveAgent(agent: ManagedAgent): Promise<void>;
+    /**
+     * Emit the agent's update, then its workspace update. Workspace updates are
+     * coalesced (see WORKSPACE_UPDATE_COALESCE_MS) unless `immediate`, which a
+     * request handler that replies after this resolves should pass.
+     */
+    forwardLiveAgent(agent: ManagedAgent, options?: {
+        immediate?: boolean;
+    }): Promise<void>;
     emitStoredRecord(record: StoredAgentRecord): Promise<AgentSnapshotPayload>;
     removeAgent(agentId: string): void;
     dispose(): void;
@@ -43,7 +50,15 @@ export interface AgentUpdatesServiceDeps {
     buildProjectPlacementForWorkspaceId(workspaceId: string): Promise<ProjectPlacementPayload | null>;
     emitWorkspaceUpdateForWorkspaceId(workspaceId: string): Promise<void>;
     logger: pino.Logger;
+    /** Coalescing window for workspace updates; defaults to WORKSPACE_UPDATE_COALESCE_MS. */
+    workspaceUpdateCoalesceMs?: number;
 }
+/**
+ * A streaming agent emits agent_state many times a second, and each one used to
+ * rebuild its workspace descriptor on the spot. Workspace updates are collected
+ * per workspace for this long and flushed once.
+ */
+export declare const WORKSPACE_UPDATE_COALESCE_MS = 100;
 /**
  * Pure predicate shared by the live subscription stream and the snapshot listing
  * pager: does an agent (with its resolved project placement) satisfy a

package/dist/server/server/session/agent-updates/agent-updates-service.js

@@ -1,4 +1,10 @@
 import { resolveEffectiveThinkingOptionId } from "../../agent/agent-projections.js";
+/**
+ * A streaming agent emits agent_state many times a second, and each one used to
+ * rebuild its workspace descriptor on the spot. Workspace updates are collected
+ * per workspace for this long and flushed once.
+ */
+export const WORKSPACE_UPDATE_COALESCE_MS = 100;
 function agentThinkingOptionMatchesFilter(agent, filter) {
     if (filter.thinkingOptionId === undefined) {
         return true;
@@ -64,6 +70,43 @@ function agentUpdateTargetId(update) {
 }
 export function createAgentUpdatesService(deps) {
     let subscription = null;
+    const coalesceMs = deps.workspaceUpdateCoalesceMs ?? WORKSPACE_UPDATE_COALESCE_MS;
+    let pendingWorkspaceIds = new Set();
+    let disposed = false;
+    let pendingWorkspaceFlush = null;
+    async function flushWorkspaceUpdates() {
+        const flush = pendingWorkspaceFlush;
+        const workspaceIds = pendingWorkspaceIds;
+        pendingWorkspaceFlush = null;
+        pendingWorkspaceIds = new Set();
+        for (const workspaceId of workspaceIds) {
+            if (disposed)
+                break;
+            try {
+                await deps.emitWorkspaceUpdateForWorkspaceId(workspaceId);
+            }
+            catch (error) {
+                deps.logger.error({ err: error, workspaceId }, "Failed to emit workspace update");
+            }
+        }
+        flush?.resolve();
+    }
+    /**
+     * Queue a workspace update and resolve once the batch holding it has flushed,
+     * so a caller that awaits still observes the emitted update.
+     */
+    function scheduleWorkspaceUpdate(workspaceId) {
+        pendingWorkspaceIds.add(workspaceId);
+        if (!pendingWorkspaceFlush) {
+            let resolve;
+            const done = new Promise((settle) => {
+                resolve = settle;
+            });
+            const timer = setTimeout(() => void flushWorkspaceUpdates(), coalesceMs);
+            pendingWorkspaceFlush = { timer, done, resolve };
+        }
+        return pendingWorkspaceFlush.done;
+    }
     function bufferOrEmit(sub, payload) {
         if (payload.kind === "upsert" && !deps.isProviderVisibleToClient(payload.agent.provider)) {
             return;
@@ -158,7 +201,7 @@ export function createAgentUpdatesService(deps) {
             });
         return payload;
     }
-    async function forwardLiveAgent(agent) {
+    async function forwardLiveAgent(agent, options) {
         try {
             const sub = subscription;
             const payload = await deps.buildAgentPayload(agent);
@@ -196,7 +239,14 @@ export function createAgentUpdatesService(deps) {
             // A lifecycle change updates exactly the agent's owning workspace, never
             // every workspace sharing its cwd. Ownership is the agent's workspaceId.
             if (payload.workspaceId) {
-                await deps.emitWorkspaceUpdateForWorkspaceId(payload.workspaceId);
+                if (options?.immediate) {
+                    // This flush covers any queued update for the same workspace.
+                    pendingWorkspaceIds.delete(payload.workspaceId);
+                    await deps.emitWorkspaceUpdateForWorkspaceId(payload.workspaceId);
+                }
+                else {
+                    await scheduleWorkspaceUpdate(payload.workspaceId);
+                }
             }
         }
         catch (error) {
@@ -205,6 +255,13 @@ export function createAgentUpdatesService(deps) {
     }
     function dispose() {
         subscription = null;
+        disposed = true;
+        if (pendingWorkspaceFlush) {
+            clearTimeout(pendingWorkspaceFlush.timer);
+            pendingWorkspaceFlush.resolve();
+            pendingWorkspaceFlush = null;
+            pendingWorkspaceIds = new Set();
+        }
     }
     return {
         beginSubscription,

package/dist/server/server/session/provider/provider-catalog-session.d.ts

@@ -66,8 +66,16 @@ export declare class ProviderCatalogSession {
     private readonly providerUsageService;
     private readonly logger;
     private unsubscribeSnapshotEvents;
+    /**
+     * Snapshot keys (resolved cwds) this client has asked about. Background work
+     * warms a snapshot per agent worktree, and pushing every one of those to every
+     * client was ~145 unsolicited updates per 30s. A client only gets pushes for the
+     * global snapshot and for cwds it requested.
+     */
+    private readonly requestedSnapshotCwds;
     constructor(options: ProviderCatalogSessionOptions);
     start(): void;
+    private noteRequestedCwd;
     dispose(): void;
     private downgradeModeIconsForClient;
     private downgradeEntryModesForClient;

package/dist/server/server/session/provider/provider-catalog-session.js

@@ -1,5 +1,5 @@
 import { getErrorMessage } from "@hyperdrive.bot/fleet-protocol/error-utils";
-import { isGlobalProviderSnapshotKey, } from "../../agent/provider-snapshot-manager.js";
+import { isGlobalProviderSnapshotKey, resolveSnapshotCwd, } from "../../agent/provider-snapshot-manager.js";
 import { expandTilde } from "../../../utils/path.js";
 // COMPAT(customModeIcons): the only mode icons known to clients before v0.1.84. Any
 // other icon name is downgraded to "ShieldCheck" for those clients.
@@ -19,6 +19,13 @@ const LEGACY_MODE_ICONS = new Set([
 export class ProviderCatalogSession {
     constructor(options) {
         this.unsubscribeSnapshotEvents = null;
+        /**
+         * Snapshot keys (resolved cwds) this client has asked about. Background work
+         * warms a snapshot per agent worktree, and pushing every one of those to every
+         * client was ~145 unsolicited updates per 30s. A client only gets pushes for the
+         * global snapshot and for cwds it requested.
+         */
+        this.requestedSnapshotCwds = new Set();
         this.host = options.host;
         this.providerSnapshotManager = options.providerSnapshotManager;
         this.providerUsageService = options.providerUsageService;
@@ -26,6 +33,9 @@ export class ProviderCatalogSession {
     }
     start() {
         const handleProviderSnapshotChange = (entries, cwd) => {
+            if (!isGlobalProviderSnapshotKey(cwd) && !this.requestedSnapshotCwds.has(cwd)) {
+                return;
+            }
             // COMPAT(providersSnapshot): keep provider visibility gating for older clients.
             const visibleEntries = entries.filter((entry) => this.host.isProviderVisibleToClient(entry.provider));
             const snapshotCwd = isGlobalProviderSnapshotKey(cwd) ? undefined : cwd;
@@ -43,6 +53,11 @@ export class ProviderCatalogSession {
             this.providerSnapshotManager.off("change", handleProviderSnapshotChange);
         };
     }
+    noteRequestedCwd(cwd) {
+        if (cwd?.trim()) {
+            this.requestedSnapshotCwds.add(resolveSnapshotCwd(expandTilde(cwd)));
+        }
+    }
     dispose() {
         if (this.unsubscribeSnapshotEvents) {
             this.unsubscribeSnapshotEvents();
@@ -78,6 +93,7 @@ export class ProviderCatalogSession {
     }
     async handleListProviderModelsRequest(msg) {
         const cwd = resolveCatalogRequestCwd(msg.cwd);
+        this.noteRequestedCwd(cwd);
         const fetchedAt = new Date().toISOString();
         const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
         if (!entry) {
@@ -125,6 +141,7 @@ export class ProviderCatalogSession {
     async handleListProviderModesRequest(msg) {
         const fetchedAt = new Date().toISOString();
         const cwd = resolveCatalogRequestCwd(msg.cwd);
+        this.noteRequestedCwd(cwd);
         const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
         if (!entry) {
             this.host.emit({
@@ -196,6 +213,7 @@ export class ProviderCatalogSession {
     async handleListProviderFeaturesRequest(msg) {
         const fetchedAt = new Date().toISOString();
         try {
+            this.noteRequestedCwd(msg.draftConfig.cwd);
             const sessionConfig = this.buildDraftAgentSessionConfig(msg.draftConfig);
             const features = await this.host.listDraftFeatures(sessionConfig);
             this.host.emit({
@@ -250,6 +268,7 @@ export class ProviderCatalogSession {
         }
     }
     async handleGetProvidersSnapshotRequest(msg) {
+        this.noteRequestedCwd(msg.cwd);
         // COMPAT(providersSnapshot): keep legacy provider-list RPCs alongside snapshot flow.
         const entries = this.providerSnapshotManager
             .getSnapshot(msg.cwd ? expandTilde(msg.cwd) : undefined)
@@ -286,6 +305,7 @@ export class ProviderCatalogSession {
     }
     async handleRefreshProvidersSnapshotRequest(msg) {
         if (msg.cwd) {
+            this.noteRequestedCwd(msg.cwd);
             await this.providerSnapshotManager.refreshSnapshotForCwd({
                 cwd: expandTilde(msg.cwd),
                 providers: msg.providers,

package/dist/server/server/session.d.ts

@@ -13,6 +13,7 @@ import type { WorkspaceGitService } from "./workspace-git-service.js";
 import { AgentManager } from "./agent/agent-manager.js";
 import type { WorkflowManager } from "./workflow/workflow-manager.js";
 import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
+import type { StoredAgentRecord } from "./agent/agent-storage.js";
 import type { AgentStorage } from "./agent/agent-storage.js";
 import { type PersistedWorkspaceRecord, type ProjectRegistry, type WorkspaceRegistry } from "./workspace-registry.js";
 import type { CohortRecorder } from "./ingestion/apply.js";
@@ -167,6 +168,15 @@ export type SessionLifecycleIntent = {
     requestId: string;
     reason: string;
 };
+/**
+ * The stored records a workspace descriptor for `workspaceIds` can depend on:
+ * records owned by one of those workspaces, running delegated records (they roll
+ * up to their delegation root, see WorkspaceDirectory), and the ancestor chain of
+ * every delegated record or live agent so the root can be resolved.
+ */
+export declare function selectRecordsForWorkspaces(records: readonly StoredAgentRecord[], liveAgents: ReadonlyArray<{
+    labels?: Record<string, unknown> | null;
+}>, workspaceIds: ReadonlySet<string>): StoredAgentRecord[];
 /**
  * Session represents a single connected client session.
  * It owns all state management, orchestration logic, and message processing.
@@ -505,6 +515,12 @@ export declare class Session {
     /** Read one background shell's captured output (tailed and redacted). */
     private handleBackgroundTaskOutputRequest;
     private handleDismissBackgroundTaskRequest;
+    /**
+     * Persist the archive and emit the archived agent, then hand back the rest
+     * (process teardown, then the workspace delta) as `background` so the caller
+     * can reply first. Stopping a busy agent and rebuilding its workspace used to
+     * sit in front of the reply.
+     */
     private archiveAgentForClose;
     private handleDetachAgentRequest;
     private handleCloseItemsRequest;