@nahisaho/katashiro-workspace 2.0.8 → 2.0.10

package/dist/docker-workspace.d.ts

@@ -0,0 +1,72 @@
+/**
+ * DockerWorkspace - Dockerコンテナ内ファイルシステムワークスペース
+ *
+ * @requirement REQ-011-04
+ */
+import type { Workspace, DockerWorkspaceConfig, FileInfo, DirectoryEntry } from './types.js';
+/**
+ * DockerWorkspace - Dockerコンテナ内でのファイル操作
+ *
+ * @example
+ * ```typescript
+ * const workspace = new DockerWorkspace({
+ *   type: 'docker',
+ *   containerId: 'container123',
+ *   workingDir: '/app',
+ * });
+ *
+ * await workspace.initialize();
+ * const content = await workspace.read('config.json');
+ * await workspace.write('output.txt', 'Hello Docker');
+ * await workspace.cleanup();
+ * ```
+ */
+export declare class DockerWorkspace implements Workspace {
+    readonly type: "docker";
+    readonly workingDir: string;
+    readonly readOnly: boolean;
+    private docker;
+    private container;
+    private containerId;
+    constructor(config: DockerWorkspaceConfig);
+    /**
+     * パスを解決
+     */
+    private resolvePath;
+    /**
+     * 書き込み可能か検証
+     */
+    private validateWritable;
+    /**
+     * コンテナ内でコマンドを実行
+     */
+    private exec;
+    initialize(): Promise<void>;
+    cleanup(): Promise<void>;
+    read(filePath: string, _encoding?: BufferEncoding): Promise<string>;
+    readBuffer(filePath: string): Promise<Buffer>;
+    write(filePath: string, content: string): Promise<void>;
+    writeBuffer(filePath: string, buffer: Buffer): Promise<void>;
+    list(dirPath: string): Promise<FileInfo[]>;
+    listEntries(dirPath: string): Promise<DirectoryEntry[]>;
+    search(pattern: string): Promise<string[]>;
+    exists(filePath: string): Promise<boolean>;
+    delete(filePath: string): Promise<void>;
+    mkdir(dirPath: string, recursive?: boolean): Promise<void>;
+    stat(filePath: string): Promise<FileInfo>;
+    copy(src: string, dest: string): Promise<void>;
+    move(src: string, dest: string): Promise<void>;
+    /**
+     * lsの出力をパース
+     */
+    private parseLsOutput;
+    /**
+     * lsエントリをパース
+     */
+    private parseLsEntries;
+    /**
+     * エラーメッセージをパース
+     */
+    private parseError;
+}
+//# sourceMappingURL=docker-workspace.d.ts.map

package/dist/docker-workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docker-workspace.d.ts","sourceRoot":"","sources":["../src/docker-workspace.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,SAAS,EACT,qBAAqB,EACrB,QAAQ,EACR,cAAc,EACf,MAAM,YAAY,CAAC;AAGpB;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,eAAgB,YAAW,SAAS;IAC/C,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,WAAW,CAAS;gBAEhB,MAAM,EAAE,qBAAqB;IAWzC;;OAEG;IACH,OAAO,CAAC,WAAW;IAOnB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;OAEG;YACW,IAAI;IAkEZ,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAE,cAAwB,GAAG,OAAO,CAAC,MAAM,CAAC;IAW5E,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAW7C,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBvD,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAe5D,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAgB1C,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAYvD,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAiB1C,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAO1C,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUvC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvD,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyBzC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9C,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcpD;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;OAEG;IACH,OAAO,CAAC,cAAc;IAmBtB;;OAEG;IACH,OAAO,CAAC,UAAU;CAkBnB"}

package/dist/docker-workspace.js

@@ -0,0 +1,595 @@
+"use strict";
+/**
+ * DockerWorkspace - Dockerコンテナ内ファイルシステムワークスペース
+ *
+ * @requirement REQ-011-04
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerWorkspace = void 0;
+var dockerode_1 = __importDefault(require("dockerode"));
+var path = __importStar(require("node:path"));
+var types_js_1 = require("./types.js");
+/**
+ * DockerWorkspace - Dockerコンテナ内でのファイル操作
+ *
+ * @example
+ * ```typescript
+ * const workspace = new DockerWorkspace({
+ *   type: 'docker',
+ *   containerId: 'container123',
+ *   workingDir: '/app',
+ * });
+ *
+ * await workspace.initialize();
+ * const content = await workspace.read('config.json');
+ * await workspace.write('output.txt', 'Hello Docker');
+ * await workspace.cleanup();
+ * ```
+ */
+var DockerWorkspace = /** @class */ (function () {
+    function DockerWorkspace(config) {
+        var _a;
+        this.type = 'docker';
+        this.containerId = config.containerId;
+        this.workingDir = config.workingDir;
+        this.readOnly = (_a = config.readOnly) !== null && _a !== void 0 ? _a : false;
+        this.docker = new dockerode_1.default({
+            socketPath: config.socketPath || types_js_1.DEFAULT_DOCKER_SOCKET,
+        });
+        this.container = this.docker.getContainer(this.containerId);
+    }
+    /**
+     * パスを解決
+     */
+    DockerWorkspace.prototype.resolvePath = function (filePath) {
+        if (path.isAbsolute(filePath)) {
+            return filePath;
+        }
+        return path.posix.join(this.workingDir, filePath);
+    };
+    /**
+     * 書き込み可能か検証
+     */
+    DockerWorkspace.prototype.validateWritable = function () {
+        if (this.readOnly) {
+            throw new types_js_1.WorkspaceError('READ_ONLY', 'Workspace is read-only');
+        }
+    };
+    /**
+     * コンテナ内でコマンドを実行
+     */
+    DockerWorkspace.prototype.exec = function (cmd) {
+        return __awaiter(this, void 0, void 0, function () {
+            var exec_1, error_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.container.exec({
+                                Cmd: cmd,
+                                AttachStdout: true,
+                                AttachStderr: true,
+                            })];
+                    case 1:
+                        exec_1 = _a.sent();
+                        return [2 /*return*/, new Promise(function (resolve, reject) {
+                                exec_1.start({ hijack: true, stdin: false }, function (err, stream) {
+                                    if (err) {
+                                        reject(new types_js_1.WorkspaceError('OPERATION_FAILED', "Exec failed: ".concat(err.message)));
+                                        return;
+                                    }
+                                    if (!stream) {
+                                        reject(new types_js_1.WorkspaceError('OPERATION_FAILED', 'No stream returned'));
+                                        return;
+                                    }
+                                    var stdout = '';
+                                    var stderr = '';
+                                    // Docker multiplexed stream handling
+                                    stream.on('data', function (chunk) {
+                                        // Docker stream format: 8-byte header + data
+                                        // First byte: 1=stdout, 2=stderr
+                                        if (chunk.length > 8) {
+                                            var streamType = chunk[0];
+                                            var data = chunk.slice(8).toString('utf-8');
+                                            if (streamType === 1) {
+                                                stdout += data;
+                                            }
+                                            else if (streamType === 2) {
+                                                stderr += data;
+                                            }
+                                        }
+                                        else {
+                                            stdout += chunk.toString('utf-8');
+                                        }
+                                    });
+                                    stream.on('end', function () { return __awaiter(_this, void 0, void 0, function () {
+                                        var inspectResult, _a;
+                                        var _b;
+                                        return __generator(this, function (_c) {
+                                            switch (_c.label) {
+                                                case 0:
+                                                    _c.trys.push([0, 2, , 3]);
+                                                    return [4 /*yield*/, exec_1.inspect()];
+                                                case 1:
+                                                    inspectResult = _c.sent();
+                                                    resolve({
+                                                        stdout: stdout.trim(),
+                                                        stderr: stderr.trim(),
+                                                        exitCode: (_b = inspectResult.ExitCode) !== null && _b !== void 0 ? _b : 0,
+                                                    });
+                                                    return [3 /*break*/, 3];
+                                                case 2:
+                                                    _a = _c.sent();
+                                                    resolve({ stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0 });
+                                                    return [3 /*break*/, 3];
+                                                case 3: return [2 /*return*/];
+                                            }
+                                        });
+                                    }); });
+                                    stream.on('error', function (error) {
+                                        reject(new types_js_1.WorkspaceError('OPERATION_FAILED', "Stream error: ".concat(error.message)));
+                                    });
+                                });
+                            })];
+                    case 2:
+                        error_1 = _a.sent();
+                        throw new types_js_1.WorkspaceError('CONNECTION_FAILED', "Failed to execute command: ".concat(error_1 instanceof Error ? error_1.message : String(error_1)));
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var info, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.container.inspect()];
+                    case 1:
+                        info = _a.sent();
+                        if (!info.State.Running) {
+                            throw new types_js_1.WorkspaceError('CONNECTION_FAILED', "Container ".concat(this.containerId, " is not running"));
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_2 = _a.sent();
+                        if (error_2 instanceof types_js_1.WorkspaceError)
+                            throw error_2;
+                        throw new types_js_1.WorkspaceError('CONNECTION_FAILED', "Failed to connect to container: ".concat(error_2 instanceof Error ? error_2.message : String(error_2)));
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.cleanup = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    DockerWorkspace.prototype.read = function (filePath_1) {
+        return __awaiter(this, arguments, void 0, function (filePath, _encoding) {
+            var resolved, result;
+            if (_encoding === void 0) { _encoding = 'utf-8'; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resolved = this.resolvePath(filePath);
+                        return [4 /*yield*/, this.exec(['cat', resolved])];
+                    case 1:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, filePath);
+                        }
+                        return [2 /*return*/, result.stdout];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.readBuffer = function (filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolved, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resolved = this.resolvePath(filePath);
+                        return [4 /*yield*/, this.exec(['cat', resolved])];
+                    case 1:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, filePath);
+                        }
+                        return [2 /*return*/, Buffer.from(result.stdout, 'utf-8')];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.write = function (filePath, content) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolved, dir, encoded, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.validateWritable();
+                        resolved = this.resolvePath(filePath);
+                        dir = path.posix.dirname(resolved);
+                        return [4 /*yield*/, this.exec(['mkdir', '-p', dir])];
+                    case 1:
+                        _a.sent();
+                        encoded = Buffer.from(content, 'utf-8').toString('base64');
+                        return [4 /*yield*/, this.exec(['sh', '-c', "echo '".concat(encoded, "' | base64 -d > '").concat(resolved, "'")])];
+                    case 2:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, filePath);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.writeBuffer = function (filePath, buffer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolved, dir, encoded, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.validateWritable();
+                        resolved = this.resolvePath(filePath);
+                        dir = path.posix.dirname(resolved);
+                        return [4 /*yield*/, this.exec(['mkdir', '-p', dir])];
+                    case 1:
+                        _a.sent();
+                        encoded = buffer.toString('base64');
+                        return [4 /*yield*/, this.exec(['sh', '-c', "echo '".concat(encoded, "' | base64 -d > '").concat(resolved, "'")])];
+                    case 2:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, filePath);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.list = function (dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolved, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resolved = this.resolvePath(dirPath);
+                        return [4 /*yield*/, this.exec([
+                                'sh',
+                                '-c',
+                                "ls -la --time-style=+%s '".concat(resolved, "' | tail -n +2"),
+                            ])];
+                    case 1:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, dirPath);
+                        }
+                        return [2 /*return*/, this.parseLsOutput(result.stdout, resolved)];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.listEntries = function (dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolved, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resolved = this.resolvePath(dirPath);
+                        return [4 /*yield*/, this.exec(['sh', '-c', "ls -la '".concat(resolved, "' | tail -n +2")])];
+                    case 1:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, dirPath);
+                        }
+                        return [2 /*return*/, this.parseLsEntries(result.stdout)];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.search = function (pattern) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.exec([
+                            'sh',
+                            '-c',
+                            "cd '".concat(this.workingDir, "' && find . -type f -name '").concat(pattern, "' 2>/dev/null | head -10000"),
+                        ])];
+                    case 1:
+                        result = _a.sent();
+                        if (result.exitCode !== 0 && result.stderr) {
+                            throw new types_js_1.WorkspaceError('OPERATION_FAILED', "Search failed: ".concat(result.stderr));
+                        }
+                        return [2 /*return*/, result.stdout
+                                .split('\n')
+                                .filter(function (line) { return line.trim(); })
+                                .map(function (line) { return line.replace(/^\.\//, ''); })];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.exists = function (filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolved, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resolved = this.resolvePath(filePath);
+                        return [4 /*yield*/, this.exec(['test', '-e', resolved])];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.exitCode === 0];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.delete = function (filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolved, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.validateWritable();
+                        resolved = this.resolvePath(filePath);
+                        return [4 /*yield*/, this.exec(['rm', '-rf', resolved])];
+                    case 1:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, filePath);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.mkdir = function (dirPath_1) {
+        return __awaiter(this, arguments, void 0, function (dirPath, recursive) {
+            var resolved, cmd, result;
+            if (recursive === void 0) { recursive = true; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.validateWritable();
+                        resolved = this.resolvePath(dirPath);
+                        cmd = recursive ? ['mkdir', '-p', resolved] : ['mkdir', resolved];
+                        return [4 /*yield*/, this.exec(cmd)];
+                    case 1:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, dirPath);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.stat = function (filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolved, result, _a, name, size, type, mtime, ctime;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        resolved = this.resolvePath(filePath);
+                        return [4 /*yield*/, this.exec([
+                                'stat',
+                                '-c',
+                                '%n|%s|%F|%Y|%W',
+                                resolved,
+                            ])];
+                    case 1:
+                        result = _b.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, filePath);
+                        }
+                        _a = result.stdout.split('|'), name = _a[0], size = _a[1], type = _a[2], mtime = _a[3], ctime = _a[4];
+                        return [2 /*return*/, {
+                                name: path.posix.basename(name),
+                                path: resolved,
+                                size: parseInt(size, 10),
+                                isDirectory: type === 'directory',
+                                modifiedAt: new Date(parseInt(mtime, 10) * 1000),
+                                createdAt: new Date(parseInt(ctime, 10) * 1000),
+                            }];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.copy = function (src, dest) {
+        return __awaiter(this, void 0, void 0, function () {
+            var srcResolved, destResolved, dir, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.validateWritable();
+                        srcResolved = this.resolvePath(src);
+                        destResolved = this.resolvePath(dest);
+                        dir = path.posix.dirname(destResolved);
+                        return [4 /*yield*/, this.exec(['mkdir', '-p', dir])];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.exec(['cp', '-r', srcResolved, destResolved])];
+                    case 2:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, src);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DockerWorkspace.prototype.move = function (src, dest) {
+        return __awaiter(this, void 0, void 0, function () {
+            var srcResolved, destResolved, dir, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.validateWritable();
+                        srcResolved = this.resolvePath(src);
+                        destResolved = this.resolvePath(dest);
+                        dir = path.posix.dirname(destResolved);
+                        return [4 /*yield*/, this.exec(['mkdir', '-p', dir])];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.exec(['mv', srcResolved, destResolved])];
+                    case 2:
+                        result = _a.sent();
+                        if (result.exitCode !== 0) {
+                            throw this.parseError(result.stderr, src);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * lsの出力をパース
+     */
+    DockerWorkspace.prototype.parseLsOutput = function (output, basePath) {
+        return output
+            .split('\n')
+            .filter(function (line) { return line.trim(); })
+            .map(function (line) {
+            var parts = line.split(/\s+/);
+            if (parts.length < 7)
+                return null;
+            var permissions = parts[0];
+            var size = parseInt(parts[4], 10);
+            var timestamp = parseInt(parts[5], 10);
+            var name = parts.slice(6).join(' ');
+            return {
+                name: name,
+                path: path.posix.join(basePath, name),
+                size: isNaN(size) ? 0 : size,
+                isDirectory: permissions.startsWith('d'),
+                modifiedAt: new Date(timestamp * 1000),
+                createdAt: new Date(timestamp * 1000),
+            };
+        })
+            .filter(function (info) { return info !== null; });
+    };
+    /**
+     * lsエントリをパース
+     */
+    DockerWorkspace.prototype.parseLsEntries = function (output) {
+        return output
+            .split('\n')
+            .filter(function (line) { return line.trim(); })
+            .map(function (line) {
+            var parts = line.split(/\s+/);
+            if (parts.length < 7)
+                return null;
+            var permissions = parts[0];
+            var name = parts.slice(8).join(' ');
+            return {
+                name: name,
+                isDirectory: permissions.startsWith('d'),
+            };
+        })
+            .filter(function (entry) { return entry !== null; });
+    };
+    /**
+     * エラーメッセージをパース
+     */
+    DockerWorkspace.prototype.parseError = function (stderr, filePath) {
+        var msg = stderr.toLowerCase();
+        if (msg.includes('no such file') || msg.includes('not found')) {
+            return new types_js_1.WorkspaceError('NOT_FOUND', "Not found: ".concat(filePath), filePath);
+        }
+        if (msg.includes('permission denied')) {
+            return new types_js_1.WorkspaceError('PERMISSION_DENIED', "Permission denied: ".concat(filePath), filePath);
+        }
+        if (msg.includes('is a directory')) {
+            return new types_js_1.WorkspaceError('IS_DIRECTORY', "Is a directory: ".concat(filePath), filePath);
+        }
+        if (msg.includes('not a directory')) {
+            return new types_js_1.WorkspaceError('NOT_DIRECTORY', "Not a directory: ".concat(filePath), filePath);
+        }
+        return new types_js_1.WorkspaceError('OPERATION_FAILED', stderr || "Operation failed: ".concat(filePath), filePath);
+    };
+    return DockerWorkspace;
+}());
+exports.DockerWorkspace = DockerWorkspace;