dsh-code 1.0.6 → 1.2.0

package/lib/session-query.mjs

@@ -0,0 +1,150 @@
+import { createHash } from "node:crypto";
+import SqliteSessionQueryEngine from "@deepseek-ai/dsh-session-query-sqlite";
+import { SessionQueryError, assertSessionHeadersCompatible, buildSessionEventSearchDocuments, readColdSessionLog } from "@deepseek-ai/dsh-session-query";
+//#region src/session-query.ts
+/**
+* Skip-tolerant session-query engine for this terminal.
+*
+* The upstream SqliteSessionQueryEngine reconciliation observes EVERY
+* persisted session before each search, and ONE unreadable source (for
+* example a pre-release session artifact the frozen format codecs reject)
+* fails the whole pass with SESSION_QUERY_PERSISTENCE_FAILED — every
+* cross-session search dies because of a single old file nobody opened
+* otherwise. This subclass overrides only the observation loop so an
+* unreadable source is skipped with a warning and the rest of the corpus
+* indexes normally; skipped sessions are retried on later reconciliations
+* and rejoin automatically once a host that can read them is installed.
+*
+* Vendored surface note: `_observeStable` and its module-local helpers are
+* private upstream; this file re-declares the observation loop against the
+* pinned @deepseek-ai line (see package.json peers) and must be re-checked
+* whenever that line moves. The engine class and the tool boundary also
+* share ONE physical parent-package instance through this bundle, which
+* restores instanceof-based typed error messages on the search path.
+*/
+const STABLE_OBSERVATION_ATTEMPTS = 2;
+function assertNotAborted(signal) {
+	if (signal?.aborted) throw new SessionQueryError("session-search aborted", "SESSION_QUERY_ABORTED");
+}
+function isAbort(error) {
+	return error instanceof SessionQueryError && error.code === "SESSION_QUERY_ABORTED";
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : "unknown error";
+}
+function observeSession(header, inheritedEventCount, events) {
+	const detachedHeader = structuredClone(header);
+	const detachedEvents = events.map((event) => structuredClone(event));
+	return {
+		header: detachedHeader,
+		inheritedEventCount,
+		documents: buildSessionEventSearchDocuments(detachedHeader.id, detachedEvents),
+		fingerprint: createHash("sha256").update(JSON.stringify({
+			header: detachedHeader,
+			inheritedEventCount,
+			events: detachedEvents
+		})).digest("base64url")
+	};
+}
+function sameHeader(a, b) {
+	return a.id === b.id && a.createdAt === b.createdAt && a.cwd === b.cwd && a.parentSession === b.parentSession && a.isSeeded === b.isSeeded && (a.delegationDepth ?? 0) === (b.delegationDepth ?? 0) && a.agentPreset === b.agentPreset;
+}
+function materializePersistenceSnapshots(snapshots) {
+	const candidate = snapshots;
+	if (!Array.isArray(candidate)) throw new Error("persistence snapshots must be an array");
+	const result = /* @__PURE__ */ new Map();
+	for (const snapshot of candidate) {
+		if (typeof snapshot.revision !== "string") throw new Error("persistence snapshot revision must be a string");
+		const header = structuredClone(snapshot.header);
+		if (result.has(header.id)) throw new Error(`persistence listed duplicate session "${header.id}"`);
+		result.set(header.id, {
+			header,
+			revision: snapshot.revision
+		});
+	}
+	return result;
+}
+function samePersistenceSnapshots(before, after) {
+	if (before.size !== after.size) return false;
+	for (const [id, first] of before) {
+		const second = after.get(id);
+		if (second === void 0 || first.revision !== second.revision || !sameHeader(first.header, second.header)) return false;
+	}
+	return true;
+}
+/**
+* The skip-tolerant observation pass: structurally the upstream loop, with
+* the per-source cold read wrapped so one unreadable session degrades to a
+* warning instead of failing every search. Exported for unit tests with an
+* injectable cold reader.
+*/
+async function observeStableWithSkip(engine, indexed, signal, readCold = readColdSessionLog) {
+	for (let attempt = 0; attempt < STABLE_OBSERVATION_ATTEMPTS; attempt += 1) {
+		assertNotAborted(signal);
+		const persistenceBinding = engine._persistenceBinding;
+		const persistence = persistenceBinding.service;
+		const initiallyLive = new Set(engine.ctx.sessions.list().map((session) => session.id));
+		let persisted = /* @__PURE__ */ new Map();
+		if (persistence !== void 0) try {
+			const canReuseIndexed = engine._lastPersistenceIdentity === void 0 || engine._lastPersistenceIdentity === persistenceBinding.identity;
+			const listOptions = signal === void 0 ? void 0 : { signal };
+			const before = await persistence.list(listOptions);
+			assertNotAborted(signal);
+			persisted = materializePersistenceSnapshots(before);
+			for (const entry of persisted.values()) {
+				if (canReuseIndexed && indexed.get(entry.header.id)?.revision === entry.revision) continue;
+				if (initiallyLive.has(entry.header.id) || engine.ctx.sessions.get(entry.header.id) !== void 0) continue;
+				assertNotAborted(signal);
+				try {
+					const loaded = await readCold(persistence, entry.header.id, signal);
+					assertNotAborted(signal);
+					assertSessionHeadersCompatible(entry.header, loaded.header);
+					entry.loaded = observeSession(loaded.header, loaded.inheritedEventCount, loaded.events);
+				} catch (error) {
+					if (isAbort(error) || signal?.aborted) throw error;
+					if (engine._persistenceBinding !== persistenceBinding) break;
+					entry.unreadable = errorMessage(error);
+					engine.ctx.logger?.warn("session-search skipped unreadable session %s: %s", entry.header.id, entry.unreadable);
+				}
+			}
+			assertNotAborted(signal);
+			const afterSnapshots = await persistence.list(listOptions);
+			assertNotAborted(signal);
+			const after = materializePersistenceSnapshots(afterSnapshots);
+			if (!samePersistenceSnapshots(persisted, after)) continue;
+			if (engine._persistenceBinding !== persistenceBinding) continue;
+		} catch (error) {
+			if (isAbort(error) || signal?.aborted) throw new SessionQueryError("session-search aborted", "SESSION_QUERY_ABORTED", { cause: error });
+			if (engine._persistenceBinding !== persistenceBinding) continue;
+			if (error instanceof SessionQueryError) throw error;
+			throw new SessionQueryError(`session-search persistence observation failed: ${errorMessage(error)}`, "SESSION_QUERY_PERSISTENCE_FAILED", { cause: error });
+		}
+		const live = /* @__PURE__ */ new Map();
+		for (const session of engine.ctx.sessions.list()) {
+			const observed = observeSession(session.header, session.inheritedEventCount, session.snapshotEvents());
+			const durable = persisted.get(session.id);
+			if (durable !== void 0 && durable.loaded === void 0) {
+				live.set(session.id, observed);
+				continue;
+			}
+			if (durable !== void 0) assertSessionHeadersCompatible(observed.header, durable.header);
+			live.set(session.id, observed);
+		}
+		if (!(initiallyLive.size === live.size && [...initiallyLive].every((id) => live.has(id)))) continue;
+		return {
+			persistenceBinding,
+			persisted,
+			live
+		};
+	}
+	throw new SessionQueryError("session-search persistence observation did not stabilize after one retry", "SESSION_QUERY_PERSISTENCE_FAILED");
+}
+const EngineBase = SqliteSessionQueryEngine;
+/** The engine this bundle mounts in place of the base `session-query-sqlite` row. */
+var SkipTolerantSessionQueryEngine = class extends EngineBase {
+	async _observeStable(indexed, signal) {
+		return await observeStableWithSkip(this, indexed, signal);
+	}
+};
+//#endregion
+export { SkipTolerantSessionQueryEngine, SkipTolerantSessionQueryEngine as default, observeStableWithSkip };

package/lib/startup.mjs

@@ -1,4 +1,4 @@
-import { t as THEME_NAMES } from "./theme-DCT8Y2xf.mjs";
+import { r as THEME_NAMES } from "./theme-7u5Qo3dF.mjs";
 import { Command } from "commander";
 import { parseCmdline } from "@deepseek-ai/dsh-cmdline";
 //#region src/startup.ts
@@ -18,7 +18,7 @@ import { parseCmdline } from "@deepseek-ai/dsh-cmdline";
 *   whose project directory matches the current working directory.
 * - `--session <id>` — create a new session under an explicit identity (the
 *   id must not exist yet).
-* - `--theme <dark|light|auto>` — the color palette; auto follows the
+* - `--theme <dark|light|prismatic|rainbow|auto>` — the color palette; auto follows the
 *   terminal (dark fallback until OSC-11 detection lands).
 * - no flags — a fresh session with a minted id.
 *
@@ -41,7 +41,7 @@ function resolveTuiStartup(options) {
 	if (options.resume === "") throw new Error("--resume needs a session id or id prefix");
 	if (options.mode === "") throw new Error("--mode needs a preset id");
 	if (options.mode !== void 0 && (options.resume !== void 0 || options.continue === true)) throw new Error("--mode applies only to a new session; it cannot be combined with --resume or --continue");
-	if (options.theme !== void 0 && !THEME_NAMES.includes(options.theme)) throw new Error("--theme must be dark, light, or auto");
+	if (options.theme !== void 0 && !THEME_NAMES.includes(options.theme)) throw new Error(`--theme must be one of: ${THEME_NAMES.join(", ")}`);
 	const input = {
 		...options.theme === void 0 ? {} : { theme: options.theme },
 		...options.prompt === void 0 || options.prompt.trim() === "" ? {} : { prompt: options.prompt.trim() },
@@ -71,7 +71,7 @@ function resolveTuiStartup(options) {
 * @returns a fresh program, so one process can parse more than once (tests).
 */
 function tuiCommand() {
-	return new Command().name("dsh --profile cli").description("DeepSeek Harness CLI core: the interactive coding terminal.").helpOption("-h, --help", "show this help").option("-r, --resume <session>", "resume the persisted session with this id (or unique id prefix)").option("-c, --continue", "resume the most recent persisted session for this working directory").option("--session <id>", "create a new session under this explicit id").option("--mode <preset>", "agent preset for a newly created session").option("--theme <name>", "color theme: dark (default), light, or auto").option("-i, --image <path>", "attach an image to the initial prompt (repeatable)", (path, paths) => [...paths, path], []).argument("[prompt...]", "initial prompt; sends immediately after startup").addHelpText("after", `
+	return new Command().name("dsh --profile cli").description("DeepSeek Harness CLI core: the interactive coding terminal.").helpOption("-h, --help", "show this help").option("-r, --resume <session>", "resume the persisted session with this id (or unique id prefix)").option("-c, --continue", "resume the most recent persisted session for this working directory").option("--session <id>", "create a new session under this explicit id").option("--mode <preset>", "agent preset for a newly created session").option("--theme <name>", "color theme: dark (default), light, prismatic, rainbow, or auto").option("-i, --image <path>", "attach an image to the initial prompt (repeatable)", (path, paths) => [...paths, path], []).argument("[prompt...]", "initial prompt; sends immediately after startup").addHelpText("after", `
 Examples:
   dsh --profile cli                       fresh session, minted id
   dsh --profile cli --resume abc123       resume session by id prefix