@chatcode/chatcode-cli 3.0.2 → 3.0.4-rc.1

package/runtime/node_modules/@deepseek-ai/dsh-storage/lib/types/backend.d.ts

@@ -86,6 +86,10 @@ export interface KvUnit {
         tables: Record<string, Record<string, unknown>>;
         global: unknown;
     }>;
+    /** Reload committed medium state before a domain refresh. Unsupported backends retain their snapshot. */
+    refresh?(): Promise<void>;
+    /** Hold a cross-process writer lock across a complete logical operation, including all its writes. */
+    exclusive?<T>(operation: () => Promise<T>): Promise<T>;
     /**
      * Read one record without loading other records. Backends without keyed
      * reads omit this member; on-demand domains require it.

package/runtime/node_modules/@deepseek-ai/dsh-storage-domain/lib/index.js

@@ -1,5 +1,7 @@
 import z from "@deepseek-ai/schemastery";
 import { UNIT_NAME_RE, storageBackendServiceKey } from "@deepseek-ai/dsh-storage";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { isDeepStrictEqual } from "node:util";
 //#region lib/types/error.js
 /**
 * Error vocabulary of the domain data form.
@@ -109,6 +111,7 @@ const noop = () => {};
 */
 var DomainImpl = class {
 	ctx;
+	spec;
 	unit;
 	onClosed;
 	/** Domain name from the spec. */
@@ -123,6 +126,7 @@ var DomainImpl = class {
 	/** Set when close finishes (chain drained, unit closed): reads reject from here on. */
 	closed = false;
 	disposal;
+	operationScope = new AsyncLocalStorage();
 	/**
 	* @param ctx - Context that carries `domain/changed` emissions.
 	* @param spec - The domain declaration.
@@ -138,6 +142,7 @@ var DomainImpl = class {
 	*/
 	constructor(ctx, spec, unit, records, globalValue, onClosed, readStored) {
 		this.ctx = ctx;
+		this.spec = spec;
 		this.unit = unit;
 		this.onClosed = onClosed;
 		this.name = spec.name;
@@ -191,6 +196,53 @@ var DomainImpl = class {
 		if (table === void 0) throw new Error(`domain '${this.name}' declares no table '${name}'`);
 		return table;
 	}
+	/** Reload eager records atomically in memory; a malformed record leaves the previous projection untouched.
+	* @returns Whether persisted records or global values changed the in-memory projection.
+	*/
+	refresh() {
+		return this.enqueue(async () => {
+			await this.unit.refresh?.();
+			const snapshot = await this.unit.loadAll();
+			const records = /* @__PURE__ */ new Map();
+			let global;
+			try {
+				for (const [name, tableSpec] of Object.entries(this.spec.tables)) {
+					const parsed = /* @__PURE__ */ new Map();
+					for (const [key, raw] of Object.entries(snapshot.tables[name] ?? {})) parsed.set(key, tableSpec.valueSchema.parse(raw));
+					records.set(name, parsed);
+				}
+				global = this.spec.global === void 0 ? void 0 : snapshot.global === null ? this.spec.global.initial : this.spec.global.schema.parse(snapshot.global);
+			} catch (error) {
+				throw new DomainError("invalid-record", `domain '${this.name}': refreshed snapshot failed validation`, { cause: error });
+			}
+			let changed = !isDeepStrictEqual(this.globalValue, global);
+			for (const [name, next] of records) {
+				const table = this.tables.get(name);
+				if (table === void 0) throw new Error(`domain '${this.name}' declares no table '${name}'`);
+				changed = table.replace(next) || changed;
+			}
+			this.globalValue = global;
+			return changed;
+		});
+	}
+	/** Nested table/global operations run on this queue slot, not behind their own awaiting parent.
+	* @param operation Work executed under the domain queue and backend writer lock.
+	* @returns The operation result after the locked work settles.
+	*/
+	exclusive(operation) {
+		if (this.operationScope.getStore()?.active) return operation();
+		return this.enqueue(async () => {
+			const run = async () => {
+				const scope = { active: true };
+				try {
+					return await this.operationScope.run(scope, operation);
+				} finally {
+					scope.active = false;
+				}
+			};
+			return await (this.unit.exclusive === void 0 ? run() : this.unit.exclusive(run));
+		});
+	}
 	/**
 	* Close this domain: reject new writes immediately, drain already-queued
 	* writes (their events still emit), close the unit, then free the name via
@@ -221,6 +273,7 @@ var DomainImpl = class {
 		}
 	}
 	enqueue(job) {
+		if (this.operationScope.getStore()?.active) return job();
 		if (this.disposing) return Promise.reject(new DomainError("closed", `domain '${this.name}' is closed`));
 		const result = this.chain.then(job);
 		this.chain = result.then(noop, noop);
@@ -241,6 +294,13 @@ var KvTableImpl = class {
 		this.tableName = tableName;
 		this.records = records;
 	}
+	replace(next) {
+		if (isDeepStrictEqual(this.records, next)) return false;
+		this.records.clear();
+		for (const [key, value] of next) this.records.set(key, value);
+		this.loaded.clear();
+		return true;
+	}
 	read(key) {
 		return this.host.enqueue(async () => {
 			if (this.host.readStored !== void 0 && !this.loaded.has(key)) {

package/runtime/node_modules/@deepseek-ai/dsh-storage-domain/lib/types/domain.d.ts

@@ -94,6 +94,10 @@ export interface Domain<S extends DomainSpec> {
     readonly name: string;
     /** Global singleton handle; a spec without `global` has no usable handle (`never`). */
     readonly global: DomainGlobalHandleOf<S>;
+    /** Reload and validate the complete medium snapshot. No events emit; the owner publishes its refreshed projection. */
+    refresh(): Promise<boolean>;
+    /** Serialize a logical operation locally and, where supported, across processes. Refresh inside the operation before writing. */
+    exclusive<T>(operation: () => Promise<T>): Promise<T>;
     /**
      * Resolve one declared table handle. Handles are stable — repeated calls
      * return the same instance.
@@ -135,6 +139,7 @@ export interface RecordDomain<S extends DomainSpec> {
  */
 export declare class DomainImpl {
     private readonly ctx;
+    private readonly spec;
     private readonly unit;
     private readonly onClosed;
     /** Domain name from the spec. */
@@ -149,6 +154,7 @@ export declare class DomainImpl {
     /** Set when close finishes (chain drained, unit closed): reads reject from here on. */
     private closed;
     private disposal?;
+    private readonly operationScope;
     /**
      * @param ctx - Context that carries `domain/changed` emissions.
      * @param spec - The domain declaration.
@@ -172,6 +178,15 @@ export declare class DomainImpl {
      * @returns the stable table handle.
      */
     table(name: string): KvTable<string, unknown>;
+    /** Reload eager records atomically in memory; a malformed record leaves the previous projection untouched.
+     * @returns Whether persisted records or global values changed the in-memory projection.
+     */
+    refresh(): Promise<boolean>;
+    /** Nested table/global operations run on this queue slot, not behind their own awaiting parent.
+     * @param operation Work executed under the domain queue and backend writer lock.
+     * @returns The operation result after the locked work settles.
+     */
+    exclusive<T>(operation: () => Promise<T>): Promise<T>;
     /**
      * Close this domain: reject new writes immediately, drain already-queued
      * writes (their events still emit), close the unit, then free the name via

package/runtime/node_modules/@deepseek-ai/dsh-storage-json/lib/index.js

@@ -3,6 +3,7 @@ import z from "@deepseek-ai/schemastery";
 import { StorageError, UNIT_NAME_RE, storageBackendServiceKey } from "@deepseek-ai/dsh-storage";
 import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
+import { withFileLock } from "@deepseek-ai/dsh-atomic-write";
 //#region lib/types/atomic.js
 /**
 * Atomic whole-file replacement for the JSON backend.
@@ -203,6 +204,30 @@ var SingleJsonUnit = class {
 		this.state = state;
 		this.onClose = onClose;
 	}
+	async refresh() {
+		this.assertOpen();
+		let text;
+		try {
+			text = await readFile(this.path, "utf8");
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		this.state = text === void 0 ? {
+			version: this.descriptor.version,
+			global: null,
+			tables: new Map(this.descriptor.tables.map((table) => [table, /* @__PURE__ */ new Map()]))
+		} : parse(text, this.descriptor);
+	}
+	async exclusive(operation) {
+		this.assertOpen();
+		const pending = withFileLock(this.path, operation, { waitMs: 1e4 });
+		this.inFlight.add(pending);
+		try {
+			return await pending;
+		} finally {
+			this.inFlight.delete(pending);
+		}
+	}
 	async loadAll() {
 		this.assertOpen();
 		const tables = {};

package/runtime/node_modules/@deepseek-ai/dsh-storage-json/package.json

@@ -31,6 +31,7 @@
     "@deepseek-ai/cordis": "workspace:~"
   },
   "dependencies": {
+    "@deepseek-ai/dsh-atomic-write": "workspace:*",
     "@deepseek-ai/schemastery": "workspace:~"
   },
   "devDependencies": {