@linxin666/dsh-client-ui-task-board 0.2.8 → 0.3.0

package/lib/index.js

@@ -204,8 +204,19 @@ function resolveDshHome(env = process.env, home = homedir()) {
 function dshHome() {
 	return resolveDshHome();
 }
-//#endregion
-//#region src/core/tasks.ts
+/**
+* Trim an execution list to at most {@link EXECUTION_HISTORY_LIMIT} records,
+* most recent last. A running (unsettled) execution is never trimmed: the
+* Host monitor and restart recovery depend on the active record, and a task
+* cannot start a new run while one is still open.
+*/
+function retainRecentExecutions(executions) {
+	if (executions.length <= 20) return [...executions];
+	const open = executions.filter((execution) => execution.endedAt === void 0);
+	const settled = executions.filter((execution) => execution.endedAt !== void 0);
+	const keepSettled = Math.max(20 - open.length, 0);
+	return [...settled.slice(Math.max(settled.length - keepSettled, 0)), ...open];
+}
 /** Statuses a settled task may be archived from. */
 const ARCHIVABLE_STATUSES = ["done", "failed"];
 /** Permission presets a task may pin on its execution session (the `/permission <id>` ids). */
@@ -307,7 +318,7 @@ function startExecution(task, now, executionId) {
 			...task,
 			status: "running",
 			updatedAt: now,
-			executions: [...task.executions, execution]
+			executions: retainRecentExecutions([...task.executions, execution])
 		},
 		execution
 	};
@@ -1014,9 +1025,10 @@ function mergeTask(a, b) {
 		const previous = byId.get(entry.id);
 		byId.set(entry.id, previous === void 0 ? entry : betterExecution(previous, entry));
 	}
+	const executions = [...byId.values()].sort((x, y) => x.startedAt - y.startedAt);
 	return {
 		...newer,
-		executions: [...byId.values()].sort((x, y) => x.startedAt - y.startedAt)
+		executions: retainRecentExecutions(executions)
 	};
 }
 function parseHostTasks(values) {
@@ -1087,6 +1099,52 @@ var HostTaskLedger = class {
 			scheduler
 		};
 	}
+	/**
+	* Runtime-only projection for the 5 s Host poll. It copies just primitive
+	* identifiers and timestamps, never the complete task/execution history or
+	* an authoritative mutable object from the ledger.
+	*/
+	runtimeView() {
+		let armedSchedules = 0;
+		const openExecutions = [];
+		for (const task of this.document.tasks) {
+			if (task.archivedAt === void 0 && task.schedule?.enabled === true) armedSchedules += 1;
+			for (const execution of task.executions) {
+				if (execution.endedAt !== void 0) continue;
+				openExecutions.push({
+					taskId: task.id,
+					executionId: execution.id,
+					sessionId: execution.sessionId,
+					startedAt: execution.startedAt
+				});
+			}
+		}
+		return {
+			armedSchedules,
+			openExecutions
+		};
+	}
+	/** Count armed, non-archived schedules without cloning task histories. */
+	armedScheduleCount() {
+		let count = 0;
+		for (const task of this.document.tasks) if (task.archivedAt === void 0 && task.schedule?.enabled === true) count += 1;
+		return count;
+	}
+	/** Return value-only references for schedules due at the supplied Host time. */
+	dueSchedules(now) {
+		const due = [];
+		for (const task of this.document.tasks) {
+			if (task.archivedAt !== void 0) continue;
+			const schedule = task.schedule;
+			if (schedule === void 0 || !schedule.enabled || schedule.nextRunAt === void 0 || schedule.nextRunAt > now) continue;
+			due.push({
+				taskId: task.id,
+				cron: schedule.cron,
+				nextRunAt: schedule.nextRunAt
+			});
+		}
+		return due;
+	}
 	subscribe(listener) {
 		this.listeners.add(listener);
 		return () => {
@@ -1314,7 +1372,10 @@ var HostTaskLedger = class {
 		try {
 			const parsed = JSON.parse(readFileSync(this.file, "utf8"));
 			if (parsed.schemaVersion !== 2 || !Array.isArray(parsed.tasks)) throw new Error("unsupported ledger schema");
-			const tasks = parseHostTasks(parsed.tasks);
+			const tasks = parseHostTasks(parsed.tasks).map((task) => ({
+				...task,
+				executions: retainRecentExecutions(task.executions)
+			}));
 			const invalidScheduleIds = parsed.tasks.flatMap((value) => {
 				if (typeof value !== "object" || value === null) return [];
 				const row = value;
@@ -2062,24 +2123,33 @@ var TaskBoardHostService = class {
 	}
 	async pollSessions() {
 		if (this.disposed) return;
-		if (!this.active && !this.hasOpenExecutions()) return;
+		if (!this.active && this.ledger.runtimeView().openExecutions.length === 0) return;
 		const running = await this.runner.listRunning();
 		const previous = this.power.snapshot();
+		if (!running.known) {
+			this.power.updateReasons({
+				runningSessions: previous.runningSessions,
+				armedSchedules: this.ledger.armedScheduleCount(),
+				sessionStateKnown: false
+			});
+			return;
+		}
+		const runtime = this.ledger.runtimeView();
 		this.power.updateReasons({
-			runningSessions: running.known ? running.count : previous.runningSessions,
-			armedSchedules: this.armedSchedules(),
-			sessionStateKnown: running.known
+			runningSessions: running.count,
+			armedSchedules: runtime.armedSchedules,
+			sessionStateKnown: true
 		});
-		if (running.known) await this.reconcileExecutions(running.items);
+		await this.reconcileExecutions(running.items, runtime.openExecutions);
 	}
 	/** Reuse the session list this poll already fetched: one list RPC per tick, not 1 + E. */
-	async reconcileExecutions(sessions) {
-		for (const task of this.ledger.state().tasks) for (const execution of task.executions) {
-			if (execution.sessionId === void 0 || execution.endedAt !== void 0) continue;
+	async reconcileExecutions(sessions, executions) {
+		for (const execution of executions) {
+			if (execution.sessionId === void 0) continue;
 			try {
 				const result = await this.runner.inspect(execution.sessionId, execution.startedAt, sessions);
 				if (result.outcome === "pending") continue;
-				this.ledger.settle(task.id, execution.id, result.outcome, "error" in result ? result.error : void 0);
+				this.ledger.settle(execution.taskId, execution.executionId, result.outcome, "error" in result ? result.error : void 0);
 			} catch {}
 		}
 	}
@@ -2093,20 +2163,14 @@ var TaskBoardHostService = class {
 			this.ledger.skipMissed(now);
 			return;
 		}
-		for (const task of this.ledger.state().tasks) {
-			if (task.archivedAt !== void 0) continue;
-			const schedule = task.schedule;
-			if (schedule === void 0 || !schedule.enabled || schedule.nextRunAt === void 0 || schedule.nextRunAt > now) continue;
+		for (const schedule of this.ledger.dueSchedules(now)) {
 			const next = nextRunAtMs(schedule.cron, schedule.nextRunAt);
-			const opened = this.ledger.openScheduled(task.id, next, now);
+			const opened = this.ledger.openScheduled(schedule.taskId, next, now);
 			if (opened !== void 0) this.scheduleLaunch(opened);
 		}
 	}
 	armedSchedules() {
-		return this.ledger.state().tasks.filter((task) => task.archivedAt === void 0 && task.schedule?.enabled === true).length;
-	}
-	hasOpenExecutions() {
-		return this.ledger.state().tasks.some((task) => task.executions.some((execution) => execution.endedAt === void 0));
+		return this.ledger.armedScheduleCount();
 	}
 	scheduleLaunch(opened) {
 		this.launch(opened).catch((error) => {
@@ -2145,6 +2209,26 @@ var TaskBoardHostService = class {
 	}
 };
 //#endregion
+//#region src/http.ts
+/** Family-default JSON response headers; callers may append or override. */
+const JSON_HEADERS = {
+	"content-type": "application/json; charset=utf-8",
+	"referrer-policy": "no-referrer"
+};
+/**
+* Write one JSON response. Default headers are the family defaults
+* (content-type and referrer-policy); caller headers are appended or
+* override them.
+*/
+function writeJson(res, status, body, headers = {}) {
+	const payload = JSON.stringify(body);
+	res.writeHead(status, {
+		...JSON_HEADERS,
+		...headers
+	});
+	res.end(payload);
+}
+//#endregion
 //#region src/loopback.ts
 /** IPv4 127/8 predicate (four decimal octets, first == 127). */
 function isIPv4Loopback(v4) {
@@ -2196,13 +2280,6 @@ const IMPORT_LIMIT = 2 * 1024 * 1024;
 const HEARTBEAT_MS = 15e3;
 /** Header replaced by an authenticated same-host reverse proxy. */
 const TASK_BOARD_PROXY_TOKEN_HEADER = "x-dsh-task-board-proxy-token";
-function json(res, status, body) {
-	res.writeHead(status, {
-		"content-type": "application/json; charset=utf-8",
-		"cache-control": "no-store"
-	});
-	res.end(JSON.stringify(body));
-}
 function parseAuthority(authority) {
 	if (authority.trim() !== authority) return void 0;
 	const match = authority.startsWith("[") ? /^\[[^\]]+\](?::([0-9]+))?$/.exec(authority) : /^[^:@/?#\s]+(?::([0-9]+))?$/.exec(authority);
@@ -2297,10 +2374,10 @@ function makeTaskBoardRoutes(service, access = {}) {
 	const resolvedAccess = resolveAccess(access);
 	const guard = (req, res) => {
 		if (isTrustedTaskBoardRequest(req, resolvedAccess)) return true;
-		json(res, 403, {
+		writeJson(res, 403, {
 			ok: false,
 			error: "forbidden"
-		});
+		}, { "cache-control": "no-store" });
 		return false;
 	};
 	return [
@@ -2308,45 +2385,45 @@ function makeTaskBoardRoutes(service, access = {}) {
 			kind: "exact",
 			path: `${TASK_BOARD_API_PREFIX}/state`,
 			handler: (req, res) => {
-				if (req.method !== "GET") return json(res, 405, {
+				if (req.method !== "GET") return writeJson(res, 405, {
 					ok: false,
 					error: "method-not-allowed"
-				});
+				}, { "cache-control": "no-store" });
 				if (!guard(req, res)) return;
-				json(res, 200, service.snapshot());
+				writeJson(res, 200, service.snapshot(), { "cache-control": "no-store" });
 			}
 		},
 		{
 			kind: "exact",
 			path: `${TASK_BOARD_API_PREFIX}/action`,
 			handler: async (req, res) => {
-				if (req.method !== "POST") return json(res, 405, {
+				if (req.method !== "POST") return writeJson(res, 405, {
 					ok: false,
 					error: "method-not-allowed"
-				});
+				}, { "cache-control": "no-store" });
 				if (!guard(req, res)) return;
-				if (!(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) return json(res, 415, {
+				if (!(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) return writeJson(res, 415, {
 					ok: false,
 					error: "json-required"
-				});
+				}, { "cache-control": "no-store" });
 				try {
 					const body = await readBody(req);
 					const parsed = parseActionEnvelope(body.value);
-					if (parsed === void 0) return json(res, 400, {
+					if (parsed === void 0) return writeJson(res, 400, {
 						ok: false,
 						error: "invalid-action"
-					});
-					if (parsed.action.kind !== "import" && Buffer.byteLength(body.raw) > ACTION_LIMIT) return json(res, 413, {
+					}, { "cache-control": "no-store" });
+					if (parsed.action.kind !== "import" && Buffer.byteLength(body.raw) > ACTION_LIMIT) return writeJson(res, 413, {
 						ok: false,
 						error: "body-too-large"
-					});
-					json(res, 200, service.apply(parsed.requestId, parsed.action));
+					}, { "cache-control": "no-store" });
+					writeJson(res, 200, service.apply(parsed.requestId, parsed.action), { "cache-control": "no-store" });
 				} catch (error) {
 					const message = error instanceof Error ? error.message : String(error);
-					json(res, message === "body-too-large" ? 413 : 400, {
+					writeJson(res, message === "body-too-large" ? 413 : 400, {
 						ok: false,
 						error: message
-					});
+					}, { "cache-control": "no-store" });
 				}
 			}
 		},

package/lib/types/core/controller.d.ts

@@ -2,17 +2,15 @@
  * Board controller: the single owner of task-ledger state and view state.
  *
  * In production it projects the Host ledger and submits confirmed actions;
- * the legacy store/execution seams remain for v1 migration tests. It also
- * closes the board whenever the user navigates to a session.
+ * the legacy store seam remains for v1 migration tests. It also closes the
+ * board whenever the user navigates to a session.
  * Framework-free (structural runtime faces) so the whole orchestration is
  * unit-testable with fakes.
  *
  * The per use-case domain transitions (create/update/delete/schedule) live in
  * dedicated modules under core/use-cases and are applied here; the controller
- * owns only the orchestration seam (state, persistence, notify, execution,
- * navigation, reconciliation).
+ * owns only the orchestration seam (state, persistence, notify, navigation).
  */
-import type { ExecutionService } from './execution.ts';
 import type { TaskStore } from './store.ts';
 import { type NewTaskInput, type TaskRecord, type TaskStatus } from './tasks.ts';
 import { type TaskUpdatePatch } from './use-cases/task-update.ts';
@@ -37,15 +35,11 @@ export interface SessionsControllerFace {
 /** Controller dependencies (all swappable in tests). */
 export interface ControllerDeps {
     store: TaskStore;
-    /** Legacy browser execution seam used only by isolated v1 tests. */
-    exec?: ExecutionService;
     sessions: SessionsControllerFace;
     /** Clock; defaults to Date.now. */
     now?: () => number;
     /** Id minting; defaults to a random-uuid. */
     uuid?: () => string;
-    /** Debounce (ms) for session-list-changed reconciles; defaults to 350. */
-    reconcileDebounceMs?: number;
     /** Host-authoritative transport; absent keeps the legacy in-memory test path. */
     transport?: TaskBoardTransport;
 }
@@ -105,7 +99,7 @@ export declare class BoardController {
     private hostState;
     private remoteSubscribed;
     private remoteInitialization;
-    /** @param deps - store, execution service, and the sessions navigation face. */
+    /** @param deps - store and the sessions navigation face. */
     constructor(deps: ControllerDeps);
     /** Load the persisted ledger and start the navigation/status subscriptions. */
     start(): void;
@@ -178,32 +172,17 @@ export declare class BoardController {
      */
     openSession(sessionId: string): void;
     /**
-     * Execute a task for real: move it to 'running', open an execution record,
-     * and hand off to the ExecutionService. A second call while the task is
-     * already running is ignored.
+     * Request a Host execution for a task: the Host ledger owns the running
+     * transition, the execution record, and the settlement. A second call
+     * while the task is already running is ignored; without a Host transport
+     * the run is refused (returns false).
      */
     runTask(id: string): Promise<boolean>;
-    /** Re-run a settled task: move it back to 'todo' first, then execute. */
+    /** Re-run a settled task through the Host (the Host replans and executes). */
     rerunTask(id: string): Promise<void>;
-    private handleExecutionEvent;
-    /** Reconcile running tasks and close the board when the user navigates. */
+    /** Close the board when the user navigates to another session. */
     private onSessionsChanged;
     private lastCurrent;
-    /** Execution ids launched on this page; they settle via their live watch, never list reconciliation. */
-    private readonly activeExecutionIds;
-    /** Debounce timer for {@link reconcileRunningTasks}. */
-    private reconcileTimer;
-    /** Whether a reconcile pass is underway (single-flight guard). */
-    private reconcileInFlight;
-    /**
-     * Debounce + single-flight trigger for the running-task reconciliation.
-     * Session-list notifications arrive in bursts (one per session status
-     * change); both guards together keep a burst from reading the history API
-     * once per running task.
-     */
-    private scheduleReconcile;
-    /** Settle tasks left 'running' whose sessions already finished. */
-    private reconcileRunningTasks;
     private persistAndNotify;
     private commitRemote;
     private performRemote;

package/lib/types/core/tasks.d.ts

@@ -25,6 +25,19 @@ export interface ExecutionRecord {
     /** Human failure text when the run failed (prompt rejection or agent error). */
     error: string | undefined;
 }
+/**
+ * Maximum number of execution records retained per task. Older settled runs
+ * are trimmed when a new execution starts so per-action ledger cost stays
+ * bounded regardless of how often a task ran before.
+ */
+export declare const EXECUTION_HISTORY_LIMIT = 20;
+/**
+ * Trim an execution list to at most {@link EXECUTION_HISTORY_LIMIT} records,
+ * most recent last. A running (unsettled) execution is never trimmed: the
+ * Host monitor and restart recovery depend on the active record, and a task
+ * cannot start a new run while one is still open.
+ */
+export declare function retainRecentExecutions(executions: readonly ExecutionRecord[]): ExecutionRecord[];
 /**
  * A scheduled-run rule attached to a task. The Host scheduler triggers the
  * task when `nextRunAt` is due and persists the rule in the Host ledger.
@@ -55,7 +68,10 @@ export interface TaskRecord {
     createdAt: number;
     /** Last mutation instant (ms epoch). */
     updatedAt: number;
-    /** Every execution attempt, most recent last. */
+    /**
+     * Execution history retained on the task, most recent last: the latest
+     * {@link EXECUTION_HISTORY_LIMIT} attempts, oldest trimmed on append.
+     */
     executions: ExecutionRecord[];
     /** Optional scheduled-run rule (absent on tasks without a schedule). */
     schedule?: ScheduleRule;

package/lib/types/host-ledger.d.ts

@@ -9,6 +9,24 @@ export interface OpenedRun {
     task: TaskRecord;
     execution: ExecutionRecord;
 }
+/** Minimal value copy used by the Host session monitor. */
+export interface OpenExecutionReference {
+    readonly taskId: string;
+    readonly executionId: string;
+    readonly sessionId: string | undefined;
+    readonly startedAt: number;
+}
+/** Minimal value copy used by the Host scheduler. */
+export interface DueScheduleReference {
+    readonly taskId: string;
+    readonly cron: string;
+    readonly nextRunAt: number;
+}
+/** Derived runtime data for one session-poll pass. */
+export interface LedgerRuntimeView {
+    readonly armedSchedules: number;
+    readonly openExecutions: readonly OpenExecutionReference[];
+}
 /**
  * Best-effort single-letter process state ('R','S','D','Z',...) or undefined
  * when no probe is available on this platform. Linux reads /proc/<pid>/stat
@@ -36,6 +54,16 @@ export declare class HostTaskLedger {
         scheduler: TaskBoardSchedulerSnapshot;
     };
     state(): LedgerState;
+    /**
+     * Runtime-only projection for the 5 s Host poll. It copies just primitive
+     * identifiers and timestamps, never the complete task/execution history or
+     * an authoritative mutable object from the ledger.
+     */
+    runtimeView(): LedgerRuntimeView;
+    /** Count armed, non-archived schedules without cloning task histories. */
+    armedScheduleCount(): number;
+    /** Return value-only references for schedules due at the supplied Host time. */
+    dueSchedules(now: number): DueScheduleReference[];
     subscribe(listener: () => void): () => void;
     dispose(): void;
     applyRequest(requestId: string, action: TaskBoardAction): {

package/lib/types/host-service.d.ts

@@ -37,7 +37,6 @@ export declare class TaskBoardHostService {
     private reconcileExecutions;
     private tickSchedule;
     private armedSchedules;
-    private hasOpenExecutions;
     private scheduleLaunch;
     private schedulePoll;
     private scheduleTick;

package/lib/types/http.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared JSON body/response helpers for the host route families: one strict
+ * bounded body reader, one lenient bounded body reader, one JSON object
+ * narrow, and one JSON writer. Previously these were copy-pasted across the
+ * package route files (routes.ts, update-routes.ts, mobile-api.ts, and each
+ * family's route module) with drifting contracts: body caps ranging 4 KiB to
+ * 1 MiB and four distinct overflow behaviors (reject, undefined, null, throw).
+ *
+ * Packages receive this file as a generated copy via scripts/sync-shared.mjs;
+ * edit this shared source and re-run the sync instead of editing a copy.
+ * Consumer code is migrated onto it in follow-up waves; no call site changes
+ * belong in the same change as its introduction.
+ * @module dsh-web-ui-shared/host/http
+ */
+import type { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from 'node:http';
+/**
+ * Strict bounded body reader: parse a request body of at most maxBytes as
+ * JSON.
+ * @throws 'body too large' past the cap, or the JSON.parse error for an
+ *   invalid or empty payload.
+ */
+export declare function readBoundedJson(req: IncomingMessage, maxBytes: number): Promise<unknown>;
+/**
+ * Lenient bounded body reader: parse a request body as JSON, or null on an
+ * empty body, invalid JSON, or a body past maxBytes (default 64 KiB).
+ * Overflow destroys the request instead of draining the remainder (no drain
+ * call, matching the current repo-wide behavior); callers must not keep
+ * reading the request afterwards. With objectOnly, non-JSON-object payloads
+ * also yield null.
+ */
+export declare function readJsonBody(req: IncomingMessage, opts?: {
+    maxBytes?: number;
+    objectOnly?: boolean;
+}): Promise<unknown | null>;
+/** Narrow a value to a JSON object, or undefined when it is not one. */
+export declare function asJsonObject(value: unknown): Record<string, unknown> | undefined;
+/**
+ * Write one JSON response. Default headers are the family defaults
+ * (content-type and referrer-policy); caller headers are appended or
+ * override them.
+ */
+export declare function writeJson(res: ServerResponse, status: number, body: unknown, headers?: OutgoingHttpHeaders): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-client-ui-task-board",
   "description": "Host-authoritative task board for the DSH Web GUI with real session execution, Host cron scheduling, and optional cross-platform idle-sleep protection; mounted without DSH source changes.",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/client/board/TaskBoard.tsx

@@ -52,9 +52,11 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
   return (
     <div className={css.board} data-dsh-taskboard-board="" data-dsh-plugin="task-board">
       <header className={css.boardHeader}>
+        {/* Shared hook: dsh-web-ui-all offsets center-view back controls beside the collapsed mobile sidebar. */}
         <button
           type="button"
           className={`${css.ghostButton} ${css.backButton}`}
+          data-dsh-center-view-back=""
           aria-label={t('board.close')}
           onClick={() => { controller.closeBoard() }}
         >