zigmini 1.0.0-beta.2 → 1.1.0-beta.1

package/src/housekeeping/registry.ts

@@ -0,0 +1,63 @@
+import { agentCollaborationCleanup, type AgentCollaborationCleanupDeps } from "./collectors/agent-collaboration.ts";
+import { agentDrafts } from "./collectors/agent-drafts.ts";
+import { agentFileTrash } from "./collectors/agent-file-trash.ts";
+import { agentTrash } from "./collectors/agent-trash.ts";
+import { attachmentCleanup, type AttachmentCleanupDeps } from "./collectors/attachment-cleanup.ts";
+import { dbBackup } from "./collectors/db-backup.ts";
+import { dockerBuildCache } from "./collectors/docker-build-cache.ts";
+import { type DockerDeps, dockerImage } from "./collectors/docker-image.ts";
+import { omoVersion } from "./collectors/omo-version.ts";
+import { type OrphanDeps, orphanTestProcess } from "./collectors/orphan-test-process.ts";
+import { reconcileWork, type ReconcileWorkDeps } from "./collectors/reconcile-work.ts";
+import { rpcDaemon } from "./collectors/rpc-daemon.ts";
+import type { GcCollector, GcContext } from "./collectors/shared.ts";
+import { tempDir } from "./collectors/temp-dir.ts";
+import { updateFile } from "./collectors/update-file.ts";
+import { worktree, type WorktreeDeps } from "./collectors/worktree.ts";
+import type { BoundCollector, Collector } from "./types.ts";
+
+export function bind<D>(collector: Collector<D>, deps: D): BoundCollector {
+	return {
+		name: collector.name,
+		role: collector.role,
+		triggers: collector.triggers,
+		confirmation: collector.confirmation,
+		reversibility: collector.reversibility,
+		find: () => collector.find(deps),
+		judge: (c) => collector.judge(c, deps),
+		act: (c) => collector.act(c, deps),
+	};
+}
+
+/**
+ * The six kinds of improvement 66, in the order the old /api/gc report lists them (src/gc.ts runs these too), then the
+ * later file kinds that the old report lists too.
+ */
+export const GC_COLLECTORS: readonly GcCollector[] = [dbBackup, agentTrash, omoVersion, updateFile, tempDir, rpcDaemon, agentFileTrash, agentDrafts];
+
+export interface RegistryDeps {
+	readonly gc: GcContext;
+	readonly orphan: OrphanDeps;
+	readonly worktree: WorktreeDeps;
+	readonly docker: DockerDeps;
+	readonly reconcile: ReconcileWorkDeps;
+	readonly attachments?: AttachmentCleanupDeps;
+	readonly collaboration?: AgentCollaborationCleanupDeps;
+}
+
+/**
+ * Every registered collector, in report order: the six ported kinds first (the old /api/gc order), then the later ones
+ * appended. Adding a target = one collector file + one line here.
+ */
+export function registry(deps: RegistryDeps): BoundCollector[] {
+	return [
+		...GC_COLLECTORS.map((c) => bind(c, deps.gc)),
+		bind(orphanTestProcess, deps.orphan),
+		bind(worktree, deps.worktree),
+		bind(dockerImage, deps.docker),
+		bind(dockerBuildCache, deps.docker),
+		bind(reconcileWork, deps.reconcile),
+		...(deps.attachments ? [bind(attachmentCleanup, deps.attachments)] : []),
+		...(deps.collaboration ? [bind(agentCollaborationCleanup, deps.collaboration)] : []),
+	];
+}

package/src/housekeeping/trash.ts

@@ -0,0 +1,59 @@
+import { existsSync, rmSync } from "node:fs";
+import { isAbsolute, sep } from "node:path";
+
+/**
+ * Housekeeping removes files and folders by moving them to the macOS Trash (installation rule "삭제는 휴지통").
+ * Order: test-only `ZGW_TRASH_BIN` (never set in production) -> `/usr/bin/trash` -> Finder through osascript. The path is
+ * always one argv entry, never part of a shell or AppleScript string. With neither command (the checkout container) only a
+ * `db-backup` is deleted for good, reported as method "deleted", why "no_macos_trash"; anything else fails and stays.
+ */
+
+export const TRASH_BIN = "/usr/bin/trash";
+export const OSASCRIPT_BIN = "/usr/bin/osascript";
+const FINDER_DELETE = ["on run argv", "tell application \"Finder\" to delete (POSIX file (item 1 of argv))", "end run"];
+
+export interface TrashResult { readonly ok: boolean; readonly method: "trash" | "deleted"; readonly error?: string; readonly why?: string }
+export type Trash = (path: string, collector: string) => Promise<TrashResult>;
+
+export interface TrashTools {
+	readonly env: Readonly<Record<string, string | undefined>>;
+	readonly exists: (bin: string) => boolean;
+	readonly run: (argv: readonly string[]) => Promise<{ code: number; stderr: string }>;
+}
+
+export function systemTrashTools(): TrashTools {
+	return {
+		env: process.env,
+		exists: existsSync,
+		run: async (argv) => {
+			const child = Bun.spawn([...argv], { stdin: "ignore", stdout: "ignore", stderr: "pipe" });
+			const stderr = await new Response(child.stderr).text();
+			return { code: await child.exited, stderr: stderr.trim() };
+		},
+	};
+}
+
+function command(path: string, tools: TrashTools): string[] | null {
+	const fake = tools.env.ZGW_TRASH_BIN;
+	if (fake !== undefined && fake !== "") return [fake, path];
+	if (tools.exists(TRASH_BIN)) return [TRASH_BIN, path];
+	if (tools.exists(OSASCRIPT_BIN)) return [OSASCRIPT_BIN, ...FINDER_DELETE.flatMap((line) => ["-e", line]), path];
+	return null;
+}
+
+export async function moveToTrash(path: string, collector = "", tools: TrashTools = systemTrashTools()): Promise<TrashResult> {
+	if (!isAbsolute(path) || path.split(sep).includes("..")) return { ok: false, method: "trash", error: "path_rejected" };
+	const argv = command(path, tools);
+	if (argv === null) {
+		if (collector !== "db-backup") return { ok: false, method: "trash", error: "no_macos_trash" };
+		rmSync(path, { recursive: true });
+		return { ok: true, method: "deleted", why: "no_macos_trash" };
+	}
+	try {
+		const run = await tools.run(argv);
+		if (run.code !== 0) return { ok: false, method: "trash", error: `trash_exit_${run.code}${run.stderr === "" ? "" : `: ${run.stderr}`}` };
+	} catch (error) {
+		return { ok: false, method: "trash", error: error instanceof Error ? error.message : String(error) };
+	}
+	return { ok: true, method: "trash" };
+}

package/src/housekeeping/types.ts

@@ -0,0 +1,31 @@
+export type Role = "reconcile" | "gc";
+export type Trigger = "start" | "update_end" | "web_open" | "doctor" | "work_event";
+export type Confirmation = "auto" | "operator" | "operator_via_main";
+export type Reversibility = "trash" | "state_reopen" | "process_none" | "irreversible";
+export interface Candidate { id: string; collector: string; target: string; reason: string; ageMs: number | null; bytes: number | null; details?: Record<string, unknown> }
+export type Verdict = { kind: "keep"; why: string } | { kind: "act"; why: string; evidence: Record<string, unknown> } | { kind: "confirm"; why: string; evidence: Record<string, unknown> };
+export interface ActResult { ok: boolean; method: "trash" | "deleted" | "sigterm" | "state" | "docker_rmi" | "git_prune"; error?: string; why?: string }
+export interface Collector<D> {
+	readonly name: string;
+	readonly role: Role;
+	readonly triggers: readonly Trigger[];
+	readonly confirmation: Confirmation;
+	readonly reversibility: Reversibility;
+	/** Read only. */
+	find(deps: D): Promise<Candidate[]>;
+	/** Safety rules; any unreadable input -> keep. */
+	judge(c: Candidate, deps: D): Promise<Verdict>;
+	act(c: Candidate, deps: D): Promise<ActResult>;
+}
+
+/** A collector with its dependencies applied, as the engine runs it. */
+export interface BoundCollector {
+	readonly name: string;
+	readonly role: Role;
+	readonly triggers: readonly Trigger[];
+	readonly confirmation: Confirmation;
+	readonly reversibility: Reversibility;
+	find(): Promise<Candidate[]>;
+	judge(c: Candidate): Promise<Verdict>;
+	act(c: Candidate): Promise<ActResult>;
+}