@dokebi/cli 0.0.0-stage → 0.1.0

package/dist/transaction.js

@@ -0,0 +1,124 @@
+// [AI:생성] CLI 변경 경계를 검증하고 부분 실패 시 원본을 복구할 기반을 구현한다.
+import { lstat, mkdir, mkdtemp, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { CliError } from './errors.js';
+import { exists, fingerprint, json, securePath } from './filesystem.js';
+export class Transaction {
+    root;
+    directory;
+    #snapshots = new Map();
+    #changes = [];
+    #keep = false;
+    constructor(root, directory) {
+        this.root = root;
+        this.directory = directory;
+    }
+    static async begin(root) {
+        const control = await securePath(root, '.dokebi');
+        await mkdir(control, { recursive: true });
+        const lock = join(control, 'lock');
+        // [AI:수정] 타입 명시와 경로 제어 문자 검증을 유지하면서 저장소 검사 규칙을 충족한다.
+        let handle;
+        try {
+            handle = await open(lock, 'wx');
+        }
+        catch (cause) {
+            throw new CliError('PROJECT_LOCKED', 'Another operation or interrupted transaction owns .dokebi/lock', { cause });
+        }
+        try {
+            await handle.writeFile(json({ pid: process.pid }));
+            await handle.close();
+            return new Transaction(root, await mkdtemp(join(control, 'transaction-')));
+        }
+        catch (cause) {
+            await handle.close().catch(() => { });
+            await rm(lock, { force: true });
+            throw cause;
+        }
+    }
+    async capture(path) {
+        if (!this.#snapshots.has(path))
+            this.#snapshots.set(path, await fingerprint(await securePath(this.root, path)));
+    }
+    async read(path) {
+        await this.capture(path);
+        return readFile(await securePath(this.root, path), 'utf8');
+    }
+    async write(path, content) {
+        const source = join(this.directory, `new-${this.#changes.length}`);
+        await writeFile(source, content);
+        await this.replace(path, source);
+    }
+    async replace(path, source) {
+        if (this.#changes.some((change) => change.path === path))
+            throw new CliError('DUPLICATE_CHANGE', path);
+        await this.capture(path);
+        this.#changes.push(source === undefined ? { path } : { path, source });
+    }
+    get paths() {
+        return this.#changes.map((change) => change.path);
+    }
+    async commit(beforeApply) {
+        for (const [path, expected] of this.#snapshots) {
+            if ((await fingerprint(await securePath(this.root, path))) !== expected) {
+                throw new CliError('CONCURRENT_CHANGE', `File changed while planning: ${path}`);
+            }
+        }
+        const journal = this.#changes.map((change, index) => ({
+            ...change,
+            backup: join(this.directory, `old-${index}`),
+            existed: this.#snapshots.get(change.path) !== null,
+            backedUp: false,
+            installed: false,
+        }));
+        await writeFile(join(this.directory, 'journal.json'), json(journal));
+        try {
+            for (const [index, change] of journal.entries()) {
+                beforeApply?.(index);
+                const target = await securePath(this.root, change.path);
+                await mkdir(dirname(target), { recursive: true });
+                if (change.existed) {
+                    await rename(target, change.backup);
+                    change.backedUp = true;
+                }
+                if (change.source) {
+                    await rename(change.source, target);
+                    change.installed = true;
+                }
+            }
+        }
+        catch (cause) {
+            const failures = [];
+            for (const change of [...journal].reverse()) {
+                try {
+                    const target = await securePath(this.root, change.path);
+                    if (change.installed)
+                        await rm(target, { recursive: true, force: true });
+                    if (change.backedUp)
+                        await rename(change.backup, target);
+                }
+                catch (error) {
+                    failures.push(error);
+                }
+            }
+            if (failures.length) {
+                this.#keep = true;
+                throw new CliError('RECOVERY_REQUIRED', `Rollback failed; preserve ${this.directory} and .dokebi/lock`, {
+                    cause: new AggregateError([cause, ...failures]),
+                });
+            }
+            throw new CliError('COMMIT_FAILED', 'Changes were rolled back', { cause });
+        }
+    }
+    async close() {
+        if (this.#keep)
+            return;
+        if (await exists(this.directory)) {
+            const stat = await lstat(this.directory);
+            if (stat.isSymbolicLink())
+                throw new CliError('UNSAFE_PATH', 'Transaction directory was replaced');
+            await rm(this.directory, { recursive: true });
+        }
+        await rm(join(this.root, '.dokebi/lock'), { force: true });
+    }
+}

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@dokebi/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "engines": {
+    "node": "^24.21.0 || ^26.11.1"
+  },
+  "bin": {
+    "dokebi": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "AI.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
+    "test": "tsc -p tsconfig.test.json && node --test \".tmp/tests/tests/*.test.js\""
+  },
+  "dependencies": {
+    "semver": "7.8.5",
+    "@dokebi/core": "0.1.0",
+    "ajv": "8.20.0"
+  },
+  "devDependencies": {
+    "@types/semver": "7.8.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.nyx-zone.com/dokebi/framework.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT"
+}