github-issue-tower-defence-management 1.152.3 → 1.153.0

package/bin/adapter/entry-points/handlers/ownerCallFileCleaner.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanClosedIssueOwnerCallFiles = void 0;
+const InTmuxByHumanSessionReconcileUseCase_1 = require("../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase");
+const ownerCallFileStore_1 = require("./ownerCallFileStore");
+const cleanClosedIssueOwnerCallFiles = (params) => {
+    const { inTmuxDataOutputDir, pjcode, issues } = params;
+    if (!inTmuxDataOutputDir || !pjcode) {
+        return;
+    }
+    for (const issue of issues.filter((candidate) => candidate.isClosed)) {
+        (0, ownerCallFileStore_1.ownerCallFileDelete)({
+            dataDir: inTmuxDataOutputDir,
+            projectCode: pjcode,
+            sessionName: (0, InTmuxByHumanSessionReconcileUseCase_1.toTmuxSessionName)(issue.url),
+        });
+    }
+};
+exports.cleanClosedIssueOwnerCallFiles = cleanClosedIssueOwnerCallFiles;
+//# sourceMappingURL=ownerCallFileCleaner.js.map

package/bin/adapter/entry-points/handlers/ownerCallFileCleaner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownerCallFileCleaner.js","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/ownerCallFileCleaner.ts"],"names":[],"mappings":";;;AACA,+HAAyG;AACzG,6DAA2D;AAQpD,MAAM,8BAA8B,GAAG,CAC5C,MAA4C,EACtC,EAAE;IACR,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACvD,IAAI,CAAC,mBAAmB,IAAI,CAAC,MAAM,EAAE,CAAC;QACpC,OAAO;IACT,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;QACrE,IAAA,wCAAmB,EAAC;YAClB,OAAO,EAAE,mBAAmB;YAC5B,WAAW,EAAE,MAAM;YACnB,WAAW,EAAE,IAAA,wDAAiB,EAAC,KAAK,CAAC,GAAG,CAAC;SAC1C,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC;AAdW,QAAA,8BAA8B,kCAczC"}

package/bin/adapter/entry-points/handlers/ownerCallFileStore.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownerCallProjectCodeInInTmuxByHumanData = exports.ownerCallFileDeleteInEveryProject = exports.ownerCallFileDelete = exports.ownerCallFileAppend = exports.ownerCallFilePath = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const OwnerCallFile_1 = require("../../../domain/usecases/intmux/OwnerCallFile");
+const ownerCallFilePath = (dataDir, projectCode, sessionName) => path_1.default.join(dataDir, (0, OwnerCallFile_1.ownerCallFileRelativePath)(projectCode, sessionName));
+exports.ownerCallFilePath = ownerCallFilePath;
+const ownerCallFileAppend = (params) => {
+    const filePath = (0, exports.ownerCallFilePath)(params.dataDir, params.projectCode, params.ownerCall.sessionName);
+    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+    fs_1.default.appendFileSync(filePath, (0, OwnerCallFile_1.ownerCallYamlDocument)(params.ownerCall));
+};
+exports.ownerCallFileAppend = ownerCallFileAppend;
+const ownerCallFileDelete = (params) => {
+    fs_1.default.rmSync((0, exports.ownerCallFilePath)(params.dataDir, params.projectCode, params.sessionName), { force: true });
+};
+exports.ownerCallFileDelete = ownerCallFileDelete;
+const projectCodeDirectoryNames = (dataDir) => {
+    const ownerCallDirectory = path_1.default.join(dataDir, OwnerCallFile_1.OWNER_CALL_FILE_DIRECTORY_NAME);
+    if (!fs_1.default.existsSync(ownerCallDirectory)) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(ownerCallDirectory, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+};
+const ownerCallFileDeleteInEveryProject = (params) => {
+    for (const projectCode of projectCodeDirectoryNames(params.dataDir)) {
+        (0, exports.ownerCallFileDelete)({
+            dataDir: params.dataDir,
+            projectCode,
+            sessionName: params.sessionName,
+        });
+    }
+};
+exports.ownerCallFileDeleteInEveryProject = ownerCallFileDeleteInEveryProject;
+// The in-tmux-by-human data the scheduled run writes into the same directory
+// serveWeb serves: one `{projectCode}.v4.json` per project, each listing the
+// sessions of that project. `index.v4.json` only names the project files, so
+// it is not read here.
+const IN_TMUX_BY_HUMAN_PROJECT_DATA_SUFFIX = '.v4.json';
+const IN_TMUX_BY_HUMAN_INDEX_FILE_NAME = `index${IN_TMUX_BY_HUMAN_PROJECT_DATA_SUFFIX}`;
+const isUnknownArray = (value) => Array.isArray(value);
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const arrayOrEmpty = (value) => isUnknownArray(value) ? value : [];
+const propertyOrUndefined = (value, key) => isRecord(value) ? value[key] : undefined;
+const sessionNamesInProjectDataFile = (filePath) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    return arrayOrEmpty(propertyOrUndefined(parsed, 'groups')).flatMap((group) => arrayOrEmpty(propertyOrUndefined(group, 'sessions'))
+        .map((session) => propertyOrUndefined(session, 'name'))
+        .filter((name) => typeof name === 'string'));
+};
+const inTmuxByHumanProjectSessionNames = (dataDir) => {
+    if (!fs_1.default.existsSync(dataDir)) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(dataDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() &&
+        entry.name.endsWith(IN_TMUX_BY_HUMAN_PROJECT_DATA_SUFFIX) &&
+        entry.name !== IN_TMUX_BY_HUMAN_INDEX_FILE_NAME)
+        .map((entry) => ({
+        projectCode: entry.name.slice(0, entry.name.length - IN_TMUX_BY_HUMAN_PROJECT_DATA_SUFFIX.length),
+        sessionNames: sessionNamesInProjectDataFile(path_1.default.join(dataDir, entry.name)),
+    }));
+};
+const ownerCallProjectCodeInInTmuxByHumanData = (dataDir, sessionName) => (0, OwnerCallFile_1.ownerCallProjectCodeOfSession)(inTmuxByHumanProjectSessionNames(dataDir), sessionName);
+exports.ownerCallProjectCodeInInTmuxByHumanData = ownerCallProjectCodeInInTmuxByHumanData;
+//# sourceMappingURL=ownerCallFileStore.js.map

package/bin/adapter/entry-points/handlers/ownerCallFileStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownerCallFileStore.js","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/ownerCallFileStore.ts"],"names":[],"mappings":";;;;;;AAAA,4CAAoB;AACpB,gDAAwB;AACxB,iFAOuD;AAmBhD,MAAM,iBAAiB,GAAG,CAC/B,OAAe,EACf,WAA0B,EAC1B,WAAmB,EACX,EAAE,CACV,cAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAA,yCAAyB,EAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;AAL7D,QAAA,iBAAiB,qBAK4C;AAEnE,MAAM,mBAAmB,GAAG,CACjC,MAAiC,EAC3B,EAAE;IACR,MAAM,QAAQ,GAAG,IAAA,yBAAiB,EAChC,MAAM,CAAC,OAAO,EACd,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,SAAS,CAAC,WAAW,CAC7B,CAAC;IACF,YAAE,CAAC,SAAS,CAAC,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1D,YAAE,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAA,qCAAqB,EAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;AACvE,CAAC,CAAC;AAVW,QAAA,mBAAmB,uBAU9B;AAEK,MAAM,mBAAmB,GAAG,CACjC,MAAiC,EAC3B,EAAE;IACR,YAAE,CAAC,MAAM,CACP,IAAA,yBAAiB,EAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,EACzE,EAAE,KAAK,EAAE,IAAI,EAAE,CAChB,CAAC;AACJ,CAAC,CAAC;AAPW,QAAA,mBAAmB,uBAO9B;AAEF,MAAM,yBAAyB,GAAG,CAAC,OAAe,EAAY,EAAE;IAC9D,MAAM,kBAAkB,GAAG,cAAI,CAAC,IAAI,CAAC,OAAO,EAAE,8CAA8B,CAAC,CAAC;IAC9E,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAE,CAAC;QACvC,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,YAAE;SACN,WAAW,CAAC,kBAAkB,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;SACxD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;SACtC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC,CAAC;AAEK,MAAM,iCAAiC,GAAG,CAC/C,MAA+C,EACzC,EAAE;IACR,KAAK,MAAM,WAAW,IAAI,yBAAyB,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;QACpE,IAAA,2BAAmB,EAAC;YAClB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,WAAW;YACX,WAAW,EAAE,MAAM,CAAC,WAAW;SAChC,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC;AAVW,QAAA,iCAAiC,qCAU5C;AAEF,6EAA6E;AAC7E,6EAA6E;AAC7E,6EAA6E;AAC7E,uBAAuB;AACvB,MAAM,oCAAoC,GAAG,UAAU,CAAC;AACxD,MAAM,gCAAgC,GAAG,QAAQ,oCAAoC,EAAE,CAAC;AAExF,MAAM,cAAc,GAAG,CAAC,KAAc,EAAsB,EAAE,CAC5D,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAEvB,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAoC,EAAE,CACpE,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AAE9C,MAAM,YAAY,GAAG,CAAC,KAAc,EAAa,EAAE,CACjD,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAErC,MAAM,mBAAmB,GAAG,CAAC,KAAc,EAAE,GAAW,EAAW,EAAE,CACnE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAE3C,MAAM,6BAA6B,GAAG,CAAC,QAAgB,EAAY,EAAE;IACnE,IAAI,MAAe,CAAC;IACpB,IAAI,CAAC;QACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,YAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,YAAY,CAAC,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3E,YAAY,CAAC,mBAAmB,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;SACjD,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;SACtD,MAAM,CAAC,CAAC,IAAI,EAAkB,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAC9D,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,gCAAgC,GAAG,CACvC,OAAe,EACiB,EAAE;IAClC,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5B,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,YAAE;SACN,WAAW,CAAC,OAAO,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;SAC7C,MAAM,CACL,CAAC,KAAK,EAAE,EAAE,CACR,KAAK,CAAC,MAAM,EAAE;QACd,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,oCAAoC,CAAC;QACzD,KAAK,CAAC,IAAI,KAAK,gCAAgC,CAClD;SACA,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACf,WAAW,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAC3B,CAAC,EACD,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,oCAAoC,CAAC,MAAM,CAChE;QACD,YAAY,EAAE,6BAA6B,CACzC,cAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAC/B;KACF,CAAC,CAAC,CAAC;AACR,CAAC,CAAC;AAEK,MAAM,uCAAuC,GAAG,CACrD,OAAe,EACf,WAAmB,EACJ,EAAE,CACjB,IAAA,6CAA6B,EAC3B,gCAAgC,CAAC,OAAO,CAAC,EACzC,WAAW,CACZ,CAAC;AAPS,QAAA,uCAAuC,2CAOhD"}

package/bin/domain/usecases/intmux/OwnerCallFile.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownerCallYamlDocument = exports.isOwnerCallCalledAtValid = exports.ownerCallProjectCodeOfSession = exports.ownerCallFileRelativePath = exports.ownerCallFileSessionKey = exports.OWNER_CALL_FILE_EXTENSION = exports.OWNER_CALL_FILE_PROJECT_CODE_FOR_NO_PROJECT = exports.OWNER_CALL_FILE_DIRECTORY_NAME = void 0;
+const InTmuxByHumanSessionReconcileUseCase_1 = require("./InTmuxByHumanSessionReconcileUseCase");
+exports.OWNER_CALL_FILE_DIRECTORY_NAME = 'call-to-user';
+exports.OWNER_CALL_FILE_PROJECT_CODE_FOR_NO_PROJECT = 'NA';
+exports.OWNER_CALL_FILE_EXTENSION = '.yaml';
+// The key one owner call file is named by. It is the tmux session name
+// derivation every other in-tmux caller uses, followed by the replacement of
+// the slashes tmux keeps but a file name cannot hold. Applying it to a name
+// that already went through it gives that same name back, so the writing side,
+// which knows the tmux session name, and the reading side, which knows the
+// issue url, reach the same file.
+const ownerCallFileSessionKey = (sessionName) => (0, InTmuxByHumanSessionReconcileUseCase_1.toTmuxSessionName)(sessionName).replace(/\//g, '_');
+exports.ownerCallFileSessionKey = ownerCallFileSessionKey;
+const ownerCallFileRelativePath = (projectCode, sessionName) => {
+    const directory = projectCode ?? exports.OWNER_CALL_FILE_PROJECT_CODE_FOR_NO_PROJECT;
+    const fileName = (0, exports.ownerCallFileSessionKey)(sessionName);
+    return `${exports.OWNER_CALL_FILE_DIRECTORY_NAME}/${directory}/${fileName}${exports.OWNER_CALL_FILE_EXTENSION}`;
+};
+exports.ownerCallFileRelativePath = ownerCallFileRelativePath;
+const ownerCallProjectCodeOfSession = (projects, sessionName) => {
+    const key = (0, exports.ownerCallFileSessionKey)(sessionName);
+    const owningProject = projects.find((project) => project.sessionNames.some((candidate) => (0, exports.ownerCallFileSessionKey)(candidate) === key));
+    return owningProject ? owningProject.projectCode : null;
+};
+exports.ownerCallProjectCodeOfSession = ownerCallProjectCodeOfSession;
+const CALLED_AT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
+const isOwnerCallCalledAtValid = (calledAt) => {
+    if (!CALLED_AT_PATTERN.test(calledAt)) {
+        return false;
+    }
+    const parsed = new Date(calledAt);
+    return (Number.isFinite(parsed.getTime()) &&
+        parsed.toISOString().replace(/\.\d{3}Z$/, 'Z') === calledAt);
+};
+exports.isOwnerCallCalledAtValid = isOwnerCallCalledAtValid;
+const BODY_INDENTATION = '  ';
+const bodyBlockLines = (body) => body
+    .replace(/\n+$/, '')
+    .split('\n')
+    .map((line) => (line.length === 0 ? '' : `${BODY_INDENTATION}${line}`));
+const ownerCallYamlDocument = (ownerCall) => [
+    '---',
+    `sessionName: ${JSON.stringify(ownerCall.sessionName)}`,
+    `calledAt: ${JSON.stringify(ownerCall.calledAt)}`,
+    `body: |${BODY_INDENTATION.length}`,
+    ...bodyBlockLines(ownerCall.body),
+    '',
+].join('\n');
+exports.ownerCallYamlDocument = ownerCallYamlDocument;
+//# sourceMappingURL=OwnerCallFile.js.map

package/bin/domain/usecases/intmux/OwnerCallFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OwnerCallFile.js","sourceRoot":"","sources":["../../../../src/domain/usecases/intmux/OwnerCallFile.ts"],"names":[],"mappings":";;;AAAA,iGAA2E;AAE9D,QAAA,8BAA8B,GAAG,cAAc,CAAC;AAEhD,QAAA,2CAA2C,GAAG,IAAI,CAAC;AAEnD,QAAA,yBAAyB,GAAG,OAAO,CAAC;AAQjD,uEAAuE;AACvE,6EAA6E;AAC7E,4EAA4E;AAC5E,+EAA+E;AAC/E,2EAA2E;AAC3E,kCAAkC;AAC3B,MAAM,uBAAuB,GAAG,CAAC,WAAmB,EAAU,EAAE,CACrE,IAAA,wDAAiB,EAAC,WAAW,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AADxC,QAAA,uBAAuB,2BACiB;AAE9C,MAAM,yBAAyB,GAAG,CACvC,WAA0B,EAC1B,WAAmB,EACX,EAAE;IACV,MAAM,SAAS,GAAG,WAAW,IAAI,mDAA2C,CAAC;IAC7E,MAAM,QAAQ,GAAG,IAAA,+BAAuB,EAAC,WAAW,CAAC,CAAC;IACtD,OAAO,GAAG,sCAA8B,IAAI,SAAS,IAAI,QAAQ,GAAG,iCAAyB,EAAE,CAAC;AAClG,CAAC,CAAC;AAPW,QAAA,yBAAyB,6BAOpC;AAOK,MAAM,6BAA6B,GAAG,CAC3C,QAAwC,EACxC,WAAmB,EACJ,EAAE;IACjB,MAAM,GAAG,GAAG,IAAA,+BAAuB,EAAC,WAAW,CAAC,CAAC;IACjD,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAC9C,OAAO,CAAC,YAAY,CAAC,IAAI,CACvB,CAAC,SAAS,EAAE,EAAE,CAAC,IAAA,+BAAuB,EAAC,SAAS,CAAC,KAAK,GAAG,CAC1D,CACF,CAAC;IACF,OAAO,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC;AAC1D,CAAC,CAAC;AAXW,QAAA,6BAA6B,iCAWxC;AAEF,MAAM,iBAAiB,GAAG,wCAAwC,CAAC;AAE5D,MAAM,wBAAwB,GAAG,CAAC,QAAgB,EAAW,EAAE;IACpE,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QACtC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClC,OAAO,CACL,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACjC,MAAM,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,CAAC,KAAK,QAAQ,CAC5D,CAAC;AACJ,CAAC,CAAC;AATW,QAAA,wBAAwB,4BASnC;AAEF,MAAM,gBAAgB,GAAG,IAAI,CAAC;AAE9B,MAAM,cAAc,GAAG,CAAC,IAAY,EAAY,EAAE,CAChD,IAAI;KACD,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;KACnB,KAAK,CAAC,IAAI,CAAC;KACX,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,gBAAgB,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC;AAErE,MAAM,qBAAqB,GAAG,CAAC,SAAoB,EAAU,EAAE,CACpE;IACE,KAAK;IACL,gBAAgB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE;IACvD,aAAa,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;IACjD,UAAU,gBAAgB,CAAC,MAAM,EAAE;IACnC,GAAG,cAAc,CAAC,SAAS,CAAC,IAAI,CAAC;IACjC,EAAE;CACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AARF,QAAA,qBAAqB,yBAQnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "github-issue-tower-defence-management",
-  "version": "1.152.3",
+  "version": "1.153.0",
   "description": "",
   "main": "bin/index.js",
   "scripts": {

package/src/adapter/entry-points/cli/index.test.ts

@@ -1,4 +1,5 @@
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import YAML from 'yaml';
 
@@ -21,6 +22,8 @@ import {
 import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparationUseCase';
 import { NotifyFinishedIssuePreparationUseCase } from '../../../domain/usecases/NotifyFinishedIssuePreparationUseCase';
 import { CheckIssueReviewReadinessUseCase } from '../../../domain/usecases/CheckIssueReviewReadinessUseCase';
+import { ownerCallFileRelativePath } from '../../../domain/usecases/intmux/OwnerCallFile';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
 
 jest.mock('../../../domain/usecases/StartPreparationUseCase');
 jest.mock('../../../domain/usecases/NotifyFinishedIssuePreparationUseCase');
@@ -2371,6 +2374,192 @@ mysteryKey: 'value'
     });
   });
 
+  describe('ownerCallFileAppend and ownerCallFileDelete', () => {
+    const issueUrl = 'https://github.com/OWNER/REPO/issues/1';
+    const otherIssueUrl = 'https://github.com/OWNER/REPO/issues/2';
+    const sessionName = toTmuxSessionName(issueUrl);
+    let ownerCallDataDir = '';
+    let bodyFilePath = '';
+
+    beforeEach(() => {
+      ownerCallDataDir = fs.mkdtempSync(
+        path.join(os.tmpdir(), 'owner-call-cli-'),
+      );
+      bodyFilePath = path.join(ownerCallDataDir, 'body.txt');
+      fs.writeFileSync(bodyFilePath, '  the call body\n\nsecond paragraph\n');
+    });
+
+    afterEach(() => {
+      fs.rmSync(ownerCallDataDir, { recursive: true, force: true });
+    });
+
+    // The in-tmux-by-human data the scheduled run writes into the same
+    // directory serveWeb serves: one file per project, each listing the
+    // sessions of that project by their raw issue url.
+    type InTmuxByHumanProjectData = {
+      projectCode: string;
+      sessionIssueUrls: string[];
+    };
+
+    const writeInTmuxByHumanData = (
+      projects: InTmuxByHumanProjectData[],
+    ): void => {
+      for (const project of projects) {
+        fs.writeFileSync(
+          path.join(ownerCallDataDir, `${project.projectCode}.v4.json`),
+          `${JSON.stringify({
+            version: 4,
+            overviewUrl: 'https://github.com/orgs/OWNER/projects/1',
+            tdpmConsoleUrl: 'http://localhost/projects/code',
+            newIssueUrl: 'https://github.com/OWNER/REPO/issues/new',
+            groups: [
+              {
+                story: 'a story',
+                sessions: project.sessionIssueUrls.map((url) => ({
+                  name: url,
+                  description: 'an issue title',
+                })),
+              },
+            ],
+          })}\n`,
+        );
+      }
+    };
+
+    const projectCodeListing = (
+      projects: InTmuxByHumanProjectData[],
+      url: string,
+    ): string | null =>
+      projects.find((project) => project.sessionIssueUrls.includes(url))
+        ?.projectCode ?? null;
+
+    const appendedFilePath = (projectCode: string | null): string =>
+      path.join(
+        ownerCallDataDir,
+        ownerCallFileRelativePath(projectCode, sessionName),
+      );
+
+    const runAppend = (calledAt: string): Promise<unknown> =>
+      program.parseAsync([
+        'node',
+        'test',
+        'ownerCallFileAppend',
+        '--session',
+        sessionName,
+        '--calledAt',
+        calledAt,
+        '--body-file',
+        bodyFilePath,
+        '--inTmuxDataDir',
+        ownerCallDataDir,
+      ]);
+
+    it('appends the call under the directory of the project whose session list holds the session', async () => {
+      const projects: InTmuxByHumanProjectData[] = [
+        { projectCode: 'other', sessionIssueUrls: [otherIssueUrl] },
+        { projectCode: 'umino', sessionIssueUrls: [issueUrl] },
+      ];
+      writeInTmuxByHumanData(projects);
+      const stdoutSpy = jest
+        .spyOn(process.stdout, 'write')
+        .mockImplementation(() => true);
+
+      await runAppend('2026-08-14T04:22:28Z');
+
+      const documents = YAML.parseAllDocuments(
+        fs.readFileSync(
+          appendedFilePath(projectCodeListing(projects, issueUrl)),
+          'utf-8',
+        ),
+      );
+      expect(documents).toHaveLength(1);
+      expect(documents[0].toJS()).toEqual({
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: '  the call body\n\nsecond paragraph\n',
+      });
+      expect(stdoutSpy).not.toHaveBeenCalled();
+
+      stdoutSpy.mockRestore();
+    });
+
+    it('appends the call under NA when no project lists the session', async () => {
+      const projects: InTmuxByHumanProjectData[] = [
+        { projectCode: 'umino', sessionIssueUrls: [otherIssueUrl] },
+      ];
+      writeInTmuxByHumanData(projects);
+
+      await runAppend('2026-08-14T04:22:28Z');
+
+      expect(projectCodeListing(projects, issueUrl)).toBeNull();
+      expect(fs.existsSync(appendedFilePath(null))).toBe(true);
+    });
+
+    it('rejects a calledAt that is not a UTC ISO-8601 timestamp with second precision', async () => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      const processExitSpy = jest
+        .spyOn(process, 'exit')
+        .mockImplementation(() => {
+          throw new Error('process.exit called');
+        });
+
+      await expect(runAppend('2026-08-14 04:22:28')).rejects.toThrow(
+        'process.exit called',
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+      expect(fs.existsSync(appendedFilePath(null))).toBe(false);
+
+      consoleErrorSpy.mockRestore();
+      processExitSpy.mockRestore();
+    });
+
+    const runDelete = (): Promise<unknown> =>
+      program.parseAsync([
+        'node',
+        'test',
+        'ownerCallFileDelete',
+        '--session',
+        sessionName,
+        '--inTmuxDataDir',
+        ownerCallDataDir,
+      ]);
+
+    it('deletes the file of the session whichever project directory holds it', async () => {
+      const projects: InTmuxByHumanProjectData[] = [
+        { projectCode: 'umino', sessionIssueUrls: [issueUrl] },
+      ];
+      writeInTmuxByHumanData(projects);
+      await runAppend('2026-08-14T04:22:28Z');
+      const writtenFilePath = appendedFilePath(
+        projectCodeListing(projects, issueUrl),
+      );
+      expect(fs.existsSync(writtenFilePath)).toBe(true);
+
+      await runDelete();
+
+      expect(fs.existsSync(writtenFilePath)).toBe(false);
+    });
+
+    it('deletes the file left behind under the project the session has since left', async () => {
+      writeInTmuxByHumanData([
+        { projectCode: 'umino', sessionIssueUrls: [issueUrl] },
+      ]);
+      await runAppend('2026-08-14T04:22:28Z');
+      writeInTmuxByHumanData([
+        { projectCode: 'umino', sessionIssueUrls: [] },
+        { projectCode: 'other', sessionIssueUrls: [issueUrl] },
+      ]);
+
+      await runDelete();
+
+      expect(fs.existsSync(appendedFilePath('umino'))).toBe(false);
+    });
+
+    it('succeeds when the file to delete is already absent', async () => {
+      await expect(runDelete()).resolves.toBeDefined();
+    });
+  });
+
   describe('runCliProgram', () => {
     const mockCheckUseCaseRejectingWith = (error: Error): void => {
       const MockedCheckUseCase = jest.mocked(CheckIssueReviewReadinessUseCase);

package/src/adapter/entry-points/cli/index.ts

@@ -63,6 +63,12 @@ import {
   loadLiveSessionOauthTokenSelectionSettings,
   resolveFleetConfigFilePath,
 } from './fleetConfig';
+import { isOwnerCallCalledAtValid } from '../../../domain/usecases/intmux/OwnerCallFile';
+import {
+  ownerCallFileAppend,
+  ownerCallFileDeleteInEveryProject,
+  ownerCallProjectCodeInInTmuxByHumanData,
+} from '../handlers/ownerCallFileStore';
 
 type StartDaemonOptions = {
   projectUrl?: string;
@@ -102,6 +108,18 @@ type ServeWebOptions = {
   dashboardProjectNames?: string;
 };
 
+type OwnerCallFileAppendOptions = {
+  session: string;
+  calledAt: string;
+  bodyFile: string;
+  inTmuxDataDir?: string;
+};
+
+type OwnerCallFileDeleteOptions = {
+  session: string;
+  inTmuxDataDir?: string;
+};
+
 const DEFAULT_IN_TMUX_DATA_DIR =
   '/home/hiromi/0_workspaces/workspace1/jsonpub/in-tmux-by-human';
 
@@ -1149,6 +1167,63 @@ program
     }
   });
 
+program
+  .command('ownerCallFileAppend')
+  .description(
+    'Append one owner call as a YAML document to the per-session owner call file. The project the session belongs to is resolved from the in-tmux-by-human data in the data directory, and a session no project lists is written under NA. The file is created when it does not exist, and every later call is appended after the existing documents so the oldest call stays first. Nothing is written to stdout on success.',
+  )
+  .requiredOption('--session <name>', 'tmux session name that raised the call')
+  .requiredOption(
+    '--calledAt <timestamp>',
+    'Time the call was raised, as UTC ISO-8601 with second precision and a trailing Z',
+  )
+  .requiredOption(
+    '--body-file <path>',
+    'Path to the file holding the call body; the body is read from a file because it is multi-line and can be long',
+  )
+  .option(
+    '--inTmuxDataDir <path>',
+    `Directory the owner call files are written under, the same directory serveWeb serves them from (default: ${DEFAULT_IN_TMUX_DATA_DIR})`,
+  )
+  .action((options: OwnerCallFileAppendOptions) => {
+    if (!isOwnerCallCalledAtValid(options.calledAt)) {
+      console.error(
+        '--calledAt must be a UTC ISO-8601 timestamp with second precision and a trailing Z, for example 2026-08-14T04:22:28Z',
+      );
+      return process.exit(1);
+    }
+    const dataDir = options.inTmuxDataDir ?? DEFAULT_IN_TMUX_DATA_DIR;
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        options.session,
+      ),
+      ownerCall: {
+        sessionName: options.session,
+        calledAt: options.calledAt,
+        body: fs.readFileSync(options.bodyFile, 'utf-8'),
+      },
+    });
+  });
+
+program
+  .command('ownerCallFileDelete')
+  .description(
+    'Delete the owner call file of one session, whichever project directory holds it, so a session that moved between projects after its call was appended leaves nothing behind. It succeeds when the file is already absent, so a reset that runs twice is not an error. Nothing is written to stdout on success.',
+  )
+  .requiredOption('--session <name>', 'tmux session name that raised the call')
+  .option(
+    '--inTmuxDataDir <path>',
+    `Directory the owner call files are written under, the same directory serveWeb serves them from (default: ${DEFAULT_IN_TMUX_DATA_DIR})`,
+  )
+  .action((options: OwnerCallFileDeleteOptions) => {
+    ownerCallFileDeleteInEveryProject({
+      dataDir: options.inTmuxDataDir ?? DEFAULT_IN_TMUX_DATA_DIR,
+      sessionName: options.session,
+    });
+  });
+
 export const reportFatalErrorAndExit = (error: unknown): void => {
   console.error(error);
   process.exit(1);