@tyhld/conductor 0.12.136 → 0.12.138
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/autoupdate.js +286 -4
- package/dist/rollback-target.js +315 -0
- package/package.json +1 -1
- package/scripts/hooks/README.md +89 -3
- package/scripts/hooks/policy.py +83 -17
- package/scripts/hooks/skill_sync_notify.py +13 -0
- package/scripts/hooks/test_dollar_quote_and_find_file.py +475 -0
- package/scripts/hooks/test_search_word_not_path.py +21 -12
- package/skills/conductor-craftsman/SKILL.md +4 -0
|
@@ -0,0 +1,315 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 版を戻すときの「戻し先の選び方」と、戻した後の「そろっているかの確かめ」(便 8a405f97)。
|
|
3
|
+
*
|
|
4
|
+
* 【なぜ要るか(実地 FshimaNP・便 eaea5f68 の重大発見1)】
|
|
5
|
+
* 先行機は 0.12.134 の自己診断が落ちて 0.12.126 へ戻った。ところが戻し先の 0.12.126 にも
|
|
6
|
+
* 管制の「疑い(suspect)」の印が付いていたため、番人の同期(update-guard.sh の ①-src)が
|
|
7
|
+
* 1バイトも配らず、~/.tyhld/hooks の番人は 0.12.134 のまま残った。
|
|
8
|
+
* =★本体だけ戻って番人が戻らない組み合わせができ、自己診断は戻した後も同じ所で落ち続けた。
|
|
9
|
+
* 戻し先は state.json の `from`(入れ替える前に入っていた版)を【無条件に】使っていたので、
|
|
10
|
+
* 印の付いた版・誰も通していない版へ黙って戻ることができた。
|
|
11
|
+
*
|
|
12
|
+
* 【決め(けいさん指示 2026-10-11)】
|
|
13
|
+
* ① 戻し先は【確認済みの版】からだけ選ぶ。確認済み=管制の段階配布の記録で
|
|
14
|
+
* ・先行機か後続機の自己診断 PASS が在り
|
|
15
|
+
* ・その版で番人に関わる項目も PASS していて
|
|
16
|
+
* ・「疑い(suspect)」「不具合(bad)」の印が無い
|
|
17
|
+
* 版。★「疑いの印が無い」だけでは選ばない(印が無い版には「まだ誰も通していない版」も含まれる)。
|
|
18
|
+
* ② 記録を読めない・条件に合う版が1つも無い → 戻し先は null(=戻さない)。呼び手が配布を止める。
|
|
19
|
+
* ③ 戻した後は、本体・番人・呼び出す設定が同じ版でそろっているかを【実物】で確かめる。
|
|
20
|
+
* 版の自己申告(控えの version=)だけに頼らず、置かれている番人の中身を配布物と
|
|
21
|
+
* 1バイト単位で見比べる=「配ったつもり」を通さない。
|
|
22
|
+
*
|
|
23
|
+
* 【ここに番人の一覧を写さない】
|
|
24
|
+
* 配る中身の正本は update-guard.sh の INSTALL_FILES 1か所だけ(便 b649d1f8 の根治)。
|
|
25
|
+
* 見比べるのは「置かれている物のうち、配布物に同じ名前が在る物」だけなので、
|
|
26
|
+
* ここは番人のファイル名を1つも持たない(番人が増えても直さなくてよい)。
|
|
27
|
+
*/
|
|
28
|
+
import { readFileSync, readdirSync, statSync } from 'node:fs';
|
|
29
|
+
import path from 'node:path';
|
|
30
|
+
import { compareVersions } from './headless.js';
|
|
31
|
+
const SEMVER = /^\d+\.\d+\.\d+$/;
|
|
32
|
+
/** 管制の「確認済みの版」の口(★読むだけ・この機の状態は1バイトも動かさない)。 */
|
|
33
|
+
export const VERIFIED_VERSIONS_PATH = '/api/conductor/machines/verified-versions';
|
|
34
|
+
const FLAGS = ['ok', 'suspect', 'bad', 'unknown'];
|
|
35
|
+
/**
|
|
36
|
+
* 管制の答えを読む。★形が違う・欄が足りない → null(=「分からない」。戻さない側へ倒す)。
|
|
37
|
+
* 版ごとの欄は、1つでも欠けていれば「確認済みではない」側へ倒す(=== true で見る)。
|
|
38
|
+
*/
|
|
39
|
+
export function parseVerifiedVersions(body) {
|
|
40
|
+
if (typeof body !== 'object' || body === null)
|
|
41
|
+
return null;
|
|
42
|
+
const list = body.versions;
|
|
43
|
+
if (!Array.isArray(list))
|
|
44
|
+
return null;
|
|
45
|
+
const out = [];
|
|
46
|
+
for (const raw of list) {
|
|
47
|
+
if (typeof raw !== 'object' || raw === null)
|
|
48
|
+
continue;
|
|
49
|
+
const r = raw;
|
|
50
|
+
const version = typeof r.version === 'string' ? r.version.trim() : '';
|
|
51
|
+
if (!SEMVER.test(version))
|
|
52
|
+
continue;
|
|
53
|
+
const flag = FLAGS.includes(r.flag) ? r.flag : 'unknown';
|
|
54
|
+
out.push({
|
|
55
|
+
version,
|
|
56
|
+
selfcheckPass: r.selfcheckPass === true,
|
|
57
|
+
guardPass: r.guardPass === true,
|
|
58
|
+
flag,
|
|
59
|
+
machine: typeof r.machine === 'string' ? r.machine : null,
|
|
60
|
+
at: typeof r.at === 'string' ? r.at : null,
|
|
61
|
+
});
|
|
62
|
+
}
|
|
63
|
+
return out;
|
|
64
|
+
}
|
|
65
|
+
/**
|
|
66
|
+
* その版は【確認済み】か。
|
|
67
|
+
* ★3つ全部が要る:自己診断 PASS の記録/番人の項目も PASS/疑い・不具合の印が無い。
|
|
68
|
+
* ★「印が無い」だけでは通さない(まだ誰も通していない版と区別がつかない)。
|
|
69
|
+
*/
|
|
70
|
+
export function isVerified(r) {
|
|
71
|
+
if (!r.selfcheckPass || !r.guardPass)
|
|
72
|
+
return false;
|
|
73
|
+
return r.flag !== 'suspect' && r.flag !== 'bad';
|
|
74
|
+
}
|
|
75
|
+
/** 確認済みでない理由を1つの短い語で(★記録に残して、あとから何が足りなかったか読めるようにする)。 */
|
|
76
|
+
function whyNotVerified(r) {
|
|
77
|
+
if (r.flag === 'suspect' || r.flag === 'bad')
|
|
78
|
+
return `${r.version}=${r.flag === 'bad' ? '不具合の印' : '疑いの印'}`;
|
|
79
|
+
if (!r.selfcheckPass)
|
|
80
|
+
return `${r.version}=自己診断 PASS の記録が無い`;
|
|
81
|
+
return `${r.version}=番人の項目の PASS が無い`;
|
|
82
|
+
}
|
|
83
|
+
/**
|
|
84
|
+
* 戻し先を選ぶ。★確認済みの版からだけ選ぶ。
|
|
85
|
+
* failing … いま落ちた版(これより古い確認済みの版だけを候補にする。null=新旧を見ない)
|
|
86
|
+
* excluded … この機で自己診断が通らなかった版(state.json の failedVersions)
|
|
87
|
+
* 選ぶのは候補のうち【いちばん新しい版】(落ちた版のすぐ下の、通ったことが分かっている版)。
|
|
88
|
+
*/
|
|
89
|
+
export function pickRollbackTarget(records, o = {}) {
|
|
90
|
+
if (records === null) {
|
|
91
|
+
return { version: null, reason: '管制の確認済みの版の記録を読めません', seen: 0, verified: 0 };
|
|
92
|
+
}
|
|
93
|
+
const excluded = o.excluded ?? [];
|
|
94
|
+
const verified = records.filter(isVerified);
|
|
95
|
+
const notVerified = records.filter((r) => !isVerified(r));
|
|
96
|
+
const usable = verified
|
|
97
|
+
.filter((r) => r.version !== o.failing)
|
|
98
|
+
.filter((r) => !excluded.includes(r.version))
|
|
99
|
+
.filter((r) => (o.failing ? compareVersions(r.version, o.failing) < 0 : true))
|
|
100
|
+
.sort((a, b) => compareVersions(b.version, a.version));
|
|
101
|
+
const seen = records.length;
|
|
102
|
+
if (usable.length === 0) {
|
|
103
|
+
const why = [
|
|
104
|
+
`管制が返した版 ${seen} 件のうち確認済みは ${verified.length} 件`,
|
|
105
|
+
notVerified.length > 0 ? `選べない版: ${notVerified.map(whyNotVerified).join('/')}` : '',
|
|
106
|
+
excluded.length > 0 ? `この機で通らなかった版: ${excluded.join(',')}` : '',
|
|
107
|
+
o.failing ? `落ちた版 ${o.failing} より古い確認済みの版が1つもありません` : '',
|
|
108
|
+
].filter((s) => s !== '');
|
|
109
|
+
return { version: null, reason: `条件に合う戻し先がありません(${why.join('・')})`, seen, verified: verified.length };
|
|
110
|
+
}
|
|
111
|
+
const got = usable[0];
|
|
112
|
+
return {
|
|
113
|
+
version: got.version,
|
|
114
|
+
reason: `戻し先に確認済みの版 ${got.version} を選びました` +
|
|
115
|
+
`(自己診断 PASS・番人の項目も PASS・印 ${got.flag}` +
|
|
116
|
+
`${got.machine ? `・記録は ${got.machine}` : ''}${got.at ? `・${got.at}` : ''})`,
|
|
117
|
+
seen,
|
|
118
|
+
verified: verified.length,
|
|
119
|
+
};
|
|
120
|
+
}
|
|
121
|
+
// ─────────────────────────────────────────────────────────────────────────────
|
|
122
|
+
// そろっているかの確かめ(本体・番人・呼び出す設定)
|
|
123
|
+
// ─────────────────────────────────────────────────────────────────────────────
|
|
124
|
+
/** 番人の置き場(★update-guard.sh の GUARD_HOME と同じ決め方)。 */
|
|
125
|
+
export function guardHomeDir(home) {
|
|
126
|
+
return path.join(home, '.tyhld', 'hooks');
|
|
127
|
+
}
|
|
128
|
+
/** 番人の正本(配布物の中)。 */
|
|
129
|
+
export function guardSourceDir(distRoot) {
|
|
130
|
+
return path.join(distRoot, 'scripts', 'hooks');
|
|
131
|
+
}
|
|
132
|
+
/** 番人を配った側の控え(update-guard.sh の DIST_LAST)。 */
|
|
133
|
+
export function guardDistRecordPath(home) {
|
|
134
|
+
return path.join(guardHomeDir(home), 'dist-source.last');
|
|
135
|
+
}
|
|
136
|
+
/** 呼び出す設定(★番人の唯一の登録場所=update-guard.sh の ①-e と同じ場所)。 */
|
|
137
|
+
export function hookSettingsPath(home) {
|
|
138
|
+
return path.join(home, '.claude', 'settings.json');
|
|
139
|
+
}
|
|
140
|
+
/** 控えの1行(`<時刻> key=value …`)を読む。読めなければ空。 */
|
|
141
|
+
export function readKvLine(file) {
|
|
142
|
+
try {
|
|
143
|
+
const line = (readFileSync(file, 'utf8').split('\n')[0] ?? '').trim();
|
|
144
|
+
const out = {};
|
|
145
|
+
for (const p of line.split(' ').slice(1)) {
|
|
146
|
+
const i = p.indexOf('=');
|
|
147
|
+
if (i > 0)
|
|
148
|
+
out[p.slice(0, i)] = p.slice(i + 1);
|
|
149
|
+
}
|
|
150
|
+
return out;
|
|
151
|
+
}
|
|
152
|
+
catch {
|
|
153
|
+
return {};
|
|
154
|
+
}
|
|
155
|
+
}
|
|
156
|
+
/** 控えの1行をそのまま(同期が走ったかを見分けるための印)。読めなければ空文字。 */
|
|
157
|
+
export function readRawLine(file) {
|
|
158
|
+
try {
|
|
159
|
+
return (readFileSync(file, 'utf8').split('\n')[0] ?? '').trim();
|
|
160
|
+
}
|
|
161
|
+
catch {
|
|
162
|
+
return '';
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
function sameBytes(a, b) {
|
|
166
|
+
try {
|
|
167
|
+
return readFileSync(a).equals(readFileSync(b));
|
|
168
|
+
}
|
|
169
|
+
catch {
|
|
170
|
+
return false;
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
function readJson(file) {
|
|
174
|
+
try {
|
|
175
|
+
const got = JSON.parse(readFileSync(file, 'utf8'));
|
|
176
|
+
return typeof got === 'object' && got !== null ? got : null;
|
|
177
|
+
}
|
|
178
|
+
catch {
|
|
179
|
+
return null;
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
/** hooks の節から、登録されている命令を全部取り出す(イベント名つき)。 */
|
|
183
|
+
function hookCommands(hooks) {
|
|
184
|
+
const out = [];
|
|
185
|
+
if (typeof hooks !== 'object' || hooks === null)
|
|
186
|
+
return out;
|
|
187
|
+
for (const [event, groups] of Object.entries(hooks)) {
|
|
188
|
+
if (!Array.isArray(groups))
|
|
189
|
+
continue;
|
|
190
|
+
for (const g of groups) {
|
|
191
|
+
if (typeof g !== 'object' || g === null)
|
|
192
|
+
continue;
|
|
193
|
+
const entries = g.hooks;
|
|
194
|
+
if (!Array.isArray(entries))
|
|
195
|
+
continue;
|
|
196
|
+
for (const h of entries) {
|
|
197
|
+
if (typeof h !== 'object' || h === null)
|
|
198
|
+
continue;
|
|
199
|
+
const cmd = h.command;
|
|
200
|
+
if (typeof cmd === 'string' && cmd.trim() !== '')
|
|
201
|
+
out.push({ event, command: cmd.trim() });
|
|
202
|
+
}
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
return out;
|
|
206
|
+
}
|
|
207
|
+
/** 命令の最後の語(=呼ばれる台本のパス)。 */
|
|
208
|
+
function lastWord(command) {
|
|
209
|
+
const parts = command.split(/\s+/);
|
|
210
|
+
return parts[parts.length - 1] ?? '';
|
|
211
|
+
}
|
|
212
|
+
/**
|
|
213
|
+
* 呼び出す設定(ホームの hooks 登録)が、本体の版と合っているか。
|
|
214
|
+
* ① 配布物の見本(settings.sample.json)が要るイベントが、全部登録されている
|
|
215
|
+
* (=新しい入口が登録漏れになっていない)
|
|
216
|
+
* ② 番人の置き場を指す登録は、その版の配布物に【在る】台本だけを指している
|
|
217
|
+
* (=戻した版に無い入口を呼んでいない。呼ぶと番人が読めず止まる)
|
|
218
|
+
* ★読めない・見本が無い → false(フェイルクローズ=合っていると言わない)。
|
|
219
|
+
*/
|
|
220
|
+
export function checkHookSettings(home, distRoot) {
|
|
221
|
+
const sample = readJson(path.join(guardSourceDir(distRoot), 'settings.sample.json'));
|
|
222
|
+
const sampleHooks = sample === null ? null : sample.hooks;
|
|
223
|
+
if (typeof sampleHooks !== 'object' || sampleHooks === null || Object.keys(sampleHooks).length === 0) {
|
|
224
|
+
return { ok: false, detail: '配布物の見本(settings.sample.json)の hooks を読めません' };
|
|
225
|
+
}
|
|
226
|
+
const dst = readJson(hookSettingsPath(home));
|
|
227
|
+
if (dst === null) {
|
|
228
|
+
return { ok: false, detail: `呼び出す設定を読めません(${hookSettingsPath(home)})` };
|
|
229
|
+
}
|
|
230
|
+
const got = hookCommands(dst.hooks);
|
|
231
|
+
const wantEvents = Object.keys(sampleHooks).sort();
|
|
232
|
+
const missing = wantEvents.filter((ev) => !got.some((c) => c.event === ev));
|
|
233
|
+
if (missing.length > 0) {
|
|
234
|
+
return { ok: false, detail: `呼び出す設定に登録が無いイベント: ${missing.join(',')}(この版の見本が要る口)` };
|
|
235
|
+
}
|
|
236
|
+
const guardHome = guardHomeDir(home);
|
|
237
|
+
const srcDir = guardSourceDir(distRoot);
|
|
238
|
+
const stale = [];
|
|
239
|
+
for (const c of got) {
|
|
240
|
+
const target = lastWord(c.command);
|
|
241
|
+
if (path.dirname(target) !== guardHome)
|
|
242
|
+
continue; // 番人の置き場を指していない登録(顧客の独自フック)は見ない
|
|
243
|
+
const name = path.basename(target);
|
|
244
|
+
const inSrc = sameBytes(target, path.join(srcDir, name));
|
|
245
|
+
if (!inSrc)
|
|
246
|
+
stale.push(`${c.event}:${name}`);
|
|
247
|
+
}
|
|
248
|
+
if (stale.length > 0) {
|
|
249
|
+
return {
|
|
250
|
+
ok: false,
|
|
251
|
+
detail: `呼び出す設定が、本体の版と違う(または無い)番人を指しています: ${stale.join(',')}`,
|
|
252
|
+
};
|
|
253
|
+
}
|
|
254
|
+
return { ok: true, detail: `呼び出す設定は本体の版に合っています(イベント ${wantEvents.join(',')})` };
|
|
255
|
+
}
|
|
256
|
+
/**
|
|
257
|
+
* 本体・番人・呼び出す設定が同じ版でそろっているか(★実物を見る)。
|
|
258
|
+
* 番人は「置かれている物のうち、配布物に同じ名前が在る物」を1バイト単位で見比べる
|
|
259
|
+
* (=番人の一覧をここに持たない)。1つでも違えば、そろっていない。
|
|
260
|
+
*/
|
|
261
|
+
export function checkAlignment(o) {
|
|
262
|
+
const { home, distRoot, body } = o;
|
|
263
|
+
const guardHome = guardHomeDir(home);
|
|
264
|
+
const srcDir = guardSourceDir(distRoot);
|
|
265
|
+
if (body === null) {
|
|
266
|
+
return { ok: false, body: null, guard: null, settings: null, detail: '本体の版を読めません' };
|
|
267
|
+
}
|
|
268
|
+
let placed = [];
|
|
269
|
+
try {
|
|
270
|
+
placed = readdirSync(guardHome);
|
|
271
|
+
}
|
|
272
|
+
catch {
|
|
273
|
+
placed = [];
|
|
274
|
+
}
|
|
275
|
+
const shared = placed.filter((n) => {
|
|
276
|
+
try {
|
|
277
|
+
return statSync(path.join(guardHome, n)).isFile() && statSync(path.join(srcDir, n)).isFile();
|
|
278
|
+
}
|
|
279
|
+
catch {
|
|
280
|
+
return false;
|
|
281
|
+
}
|
|
282
|
+
});
|
|
283
|
+
if (shared.length === 0) {
|
|
284
|
+
// 番人が置かれていないPC(そろえる対象が無い)。★ここから番人を新しく置く道は1本も無い。
|
|
285
|
+
return {
|
|
286
|
+
ok: true,
|
|
287
|
+
body,
|
|
288
|
+
guard: null,
|
|
289
|
+
settings: null,
|
|
290
|
+
detail: `本体 ${body}/番人はこのPCに置かれていないので、そろえる対象がありません`,
|
|
291
|
+
};
|
|
292
|
+
}
|
|
293
|
+
const diff = shared.filter((n) => !sameBytes(path.join(guardHome, n), path.join(srcDir, n)));
|
|
294
|
+
const rec = readKvLine(guardDistRecordPath(home));
|
|
295
|
+
const recNote = rec.status
|
|
296
|
+
? `番人を配った控え: status=${rec.status} reason=${rec.reason ?? '不明'} version=${rec.version ?? '不明'}`
|
|
297
|
+
: '番人を配った控えがありません';
|
|
298
|
+
if (diff.length > 0) {
|
|
299
|
+
return {
|
|
300
|
+
ok: false,
|
|
301
|
+
body,
|
|
302
|
+
guard: false,
|
|
303
|
+
settings: null,
|
|
304
|
+
detail: `本体 ${body} と置かれている番人が違います(${diff.length}/${shared.length} 件ちがう: ${diff.slice(0, 5).join(',')})。${recNote}`,
|
|
305
|
+
};
|
|
306
|
+
}
|
|
307
|
+
const s = checkHookSettings(home, distRoot);
|
|
308
|
+
return {
|
|
309
|
+
ok: s.ok,
|
|
310
|
+
body,
|
|
311
|
+
guard: true,
|
|
312
|
+
settings: s.ok,
|
|
313
|
+
detail: `本体 ${body}/番人は本体と同じ中身(${shared.length} 件)/${s.detail}。${recNote}`,
|
|
314
|
+
};
|
|
315
|
+
}
|
package/package.json
CHANGED
package/scripts/hooks/README.md
CHANGED
|
@@ -641,9 +641,95 @@ TYHLD-platform の2便が、**読むだけの検索**で同じ `danger` に止
|
|
|
641
641
|
|
|
642
642
|
### 分かっている限界
|
|
643
643
|
|
|
644
|
-
-
|
|
645
|
-
|
|
646
|
-
|
|
644
|
+
- ~~**`$'…'` のような引用符で始まらない書き方で割れた探す言葉は、今までどおりパスとして測られます**~~
|
|
645
|
+
→ **1-12 で直しました**(「引用符で始まるか」ではなく「語の割り方が素朴分割へ倒れたか」で見る形に替えた)。
|
|
646
|
+
- **`-f` / `--file` と `-e` が混ざった形では、1つも外しません**(安全側に倒したまま)。
|
|
647
|
+
- **番人が古い機体では効きません。** 各PCで人が1回配布を流すまで、その機では今までどおりです。
|
|
648
|
+
|
|
649
|
+
## 1-12. ★割れたかどうかは「倒れたか」で見る・名指しを読み切る(便 362a7759/220a1e2c・2026-10-12)
|
|
650
|
+
|
|
651
|
+
### なぜ要るか(便 362a7759 の実地・読み違いで便が丸ごと止まった)
|
|
652
|
+
|
|
653
|
+
1-11 で直した形の**仲間が3つ残っていました**。`danger` の後は便の残りが止まるので(1-9)、
|
|
654
|
+
**読み違い1回で便が丸ごと止まります**。あわせて、**同じ1行から出ていた止め漏れ**も見つかりました。
|
|
655
|
+
|
|
656
|
+
| 形 | 何が起きたか | どの判定が読み違えたか |
|
|
657
|
+
| --- | --- | --- |
|
|
658
|
+
| **形A** | `$'…'` / `$"…"` / `x'…'` のように**引用符で始まらない書き方**で割れた探す言葉が、今までどおりパスとして測られ `danger` | `_pattern_word_positions`(最初の語が引用符そのもので始まるときだけ続きを外していた) |
|
|
659
|
+
| **形B** | `find <実在のファイル> -exec <読む道具> {} +` が**作業場所(リポの根)に倒れ**、根の秘密に当たって `danger` | `_find_feed_danger`(探す場所を**実在のフォルダだけ**で集めていた) |
|
|
660
|
+
| **形C** | 割れていない探す言葉(`-rn "'" <フォルダ>`)で**名指しのフォルダまで探す言葉として食い**、場所が無い扱いで `danger` | 形A と同じ1行 |
|
|
661
|
+
| **★穴H** | 同じ理由で**名指しの秘密のファイルまで探す言葉として読み飛ばし**、`-n "'" <秘密のファイル>` が**通っていた**(止め漏れ) | 形A と同じ1行 |
|
|
662
|
+
| **形D** | `--regexp=<語>` のように**値を `=` で繋げた旗**で探す言葉を渡すと、**名指しの探す場所を探す言葉と取り違え**、場所が0件になって「全体の再帰検索」に倒れ `discipline`(★探す言葉の中身とは無関係・普通の語でも止まっていた) | `_disc_search`(探す言葉を旗で明示する形を**空白で区切った書き方だけ**で見ていた) |
|
|
663
|
+
|
|
664
|
+
### どう直したか
|
|
665
|
+
|
|
666
|
+
- **形A・形C・穴H(1つの根っこ)** … 続きを外すかを「**引用符で始まるか**」ではなく
|
|
667
|
+
「**語の割り方が素朴分割へ倒れたか**」で見る形に替えました(新しい部品 `naive_token_split`。
|
|
668
|
+
`tokens_of` が倒れる条件と**同じ道具**で、割れたかどうかを決める所を1か所に寄せた)。
|
|
669
|
+
倒れたときだけ引用符が閉じるまでの語を続きとして外し、**倒れていなければ1つも外しません**
|
|
670
|
+
(引用符は剥がされているので、探す言葉は必ず1語で閉じている)。
|
|
671
|
+
★これで「引用符で始まらない書き方で続きを外せない(形A・形C)」と
|
|
672
|
+
「割れていないのに続きを外して名指しの秘密を読み飛ばす(穴H)」が**同時に**正しくなります。
|
|
673
|
+
- **形B** … `_find_feed_danger` が探す場所を集めるとき、**実在のファイル**も見るようにしました。
|
|
674
|
+
名指しの先が実在のファイルだけなら作業場所に倒さず、その段で名指しした**実在の秘密のファイル**は
|
|
675
|
+
今までどおり止めます(名指しの先そのものと、`-exec` の側に書いた名前の両方を見る)。
|
|
676
|
+
★1-10 が `_recursive_read_danger` で直した原因①と**同じ病気が find の判定に残っていた**形です。
|
|
677
|
+
- **形D** … `_disc_search` に、`--regexp=<語>` / `--file=<パス>` のように
|
|
678
|
+
**値を `=` で繋げた1語**も「探す言葉は旗で示されている」として読ませました(`_disc_pattern_joined`)。
|
|
679
|
+
★秘密の判定(`pattern_arg_positions`)は 1-11 から `--regexp=` を読めていたので、
|
|
680
|
+
食い違っていたのは**作法の判定の側だけ**でした。
|
|
681
|
+
|
|
682
|
+
### ★止める側は緩めていない(1件も減らない)
|
|
683
|
+
|
|
684
|
+
- 狭めるのは「探す文字」と「**実在が確かめられたファイル**」だけで、**名指しのパスは1つも外しません**
|
|
685
|
+
(`-f` / `--file` の値も今までどおりパス)。
|
|
686
|
+
- クォートが壊れた切れ端で外した分は、同じ命令を**本物の区切り**(引用符を守る割り方)で
|
|
687
|
+
必ず測り直します(`_real_segments`・便 2.5)。
|
|
688
|
+
- 形D の直しは**探す場所を正しく数える**だけなので、場所を書かない形・点1つ・リポの根は
|
|
689
|
+
今までどおり止まります(下の 止12〜止14)。
|
|
690
|
+
- **秘密として扱う名前の判定・読み書き持ち出しの動詞の一覧は1文字も変えていません。**
|
|
691
|
+
|
|
692
|
+
### 止める/通す(実測)
|
|
693
|
+
|
|
694
|
+
| # | 形 | 判定 | 理由 |
|
|
695
|
+
| --- | --- | --- | --- |
|
|
696
|
+
| 通1 | `<検索の道具> -n $'env: <語>\|home:' <名指しのファイル>`(形A) | **通す**(前は `danger`) | 倒れた切れ端の続きは探す言葉 |
|
|
697
|
+
| 通2 | 同じ形で `$"…"` / `x'…'` / 名指しのフォルダ・ファイル2つ・別の道具・`-e` の値・`--regexp=` の値 | **通す**(同) | 同 |
|
|
698
|
+
| 通3 | `<検索の道具> -rn "'" <名指しのフォルダ>`(形C) | **通す**(同) | 倒れていないので続きを外さない |
|
|
699
|
+
| 通4 | `find <実在のファイル> -exec <読む道具> {} +`(形B) | **通す**(同) | 名指しの先を読み切る |
|
|
700
|
+
| 通5 | 同じ形で ファイル2つ・`\| xargs`・検索の道具・`-execdir`・`-type f`・`-exec … \;` | **通す**(同) | 同 |
|
|
701
|
+
| 通6 | `<検索の道具> -rn --regexp=<語> <名指しのフォルダ>`(形D) | **通す**(前は `discipline`) | 繋げた旗でも探す場所を読み切る |
|
|
702
|
+
| 通7 | 同じ形で `--file=<普通のファイル>` / 別の道具 / ファイルを名指し | **通す**(同) | 同 |
|
|
703
|
+
| 止1 | 形Aの書き方+**秘密のファイルを名指し**(素・`-e`・`$"…"`) | **danger** | 本物の区切りの側で止まる |
|
|
704
|
+
| 止2 | 形Aの書き方で**作業場所の根**・点1つ・場所を書かない・実在しない場所・しるし(`*`)を含む場所 | **danger** | 作業場所として判定(前からの安全側) |
|
|
705
|
+
| 止3 | 形Aの書き方で**秘密を含むフォルダ**を名指し | **danger** | 探した場所の中に秘密が在る |
|
|
706
|
+
| 止4 | `-f` / `--file` の値が秘密のファイル(空白区切り・`=` で繋げた形の両方) | **danger** | 探す文字が書いてあるファイル=パス |
|
|
707
|
+
| 止5 | `find` で**秘密のファイルを名指し**・名前を並べて渡す・普通のファイルと混ぜる・`-exec` の側に書く | **danger** | 名指しの先が秘密 |
|
|
708
|
+
| 止6 | `find` で**秘密を含むフォルダ**・そのフォルダとファイルの混ぜ・作業場所の根・場所を書かない・実在しない場所 | **danger** | 前からの安全側 |
|
|
709
|
+
| 止7 | ★`<検索の道具> -n "'" <秘密のファイル>`(**穴H**・引用符1字/引用符で始まる語/`-e` の値/`--regexp=` の値/秘密と普通を並べる/別の道具) | **danger**(**前は通っていた**) | 名指しの秘密を探す言葉として読み飛ばさない |
|
|
710
|
+
| 止8 | `--regexp=<語>` +秘密のファイル・秘密を含むフォルダ・作業場所の根 | **danger** | 繋げた旗でも名指しはパス |
|
|
711
|
+
| 止9 | 記録の外まで読む旗つきで場所を書かない | **danger** | 前からの安全側(1-10) |
|
|
712
|
+
| 止10 | 秘密のファイルを読む(別の動詞)・秘密の環境変数の露出・変数を含む再帰の削除・フォルダごとの複製 | **danger** | ほかの判定(1文字も変えていない) |
|
|
713
|
+
| 止11 | この形と、同じ行の危険(秘密の読み・強い上書きの push・根を `find` ほか) | **danger** | ほかの判定が先に当たる |
|
|
714
|
+
| 止12 | `--regexp=<語>` / `--file=<パス>` で**探す場所を書かない**・点1つ | **discipline** | 全体の再帰検索(緩めていない) |
|
|
715
|
+
| 止13 | 旗なし・`-e` つきで探す場所を書かない・点1つ(前からの形) | **discipline** | 同 |
|
|
716
|
+
| 止14 | 別の道具の `--regexp=<語>` で探す場所を書かない | **discipline** | 同 |
|
|
717
|
+
|
|
718
|
+
直す前(`9b76b49`=0.12.137)と後を**104形**で突き合わせ、
|
|
719
|
+
**変わらない69**(止まり続ける `danger` 37 + 止まり続ける `discipline` 8 + 通り続ける 24。
|
|
720
|
+
うち**14形は判定が同じで理由の文だけが正確になった**=読み違いの語ではなく**本物の秘密の名前**を指すようになった)/
|
|
721
|
+
**★止まる→通る29**(形A 11・形B 8・形C 4・形D 6)/
|
|
722
|
+
**★通る→止まる6**(★**すべて穴H=止め漏れを塞いだ分**・いずれも名指しの秘密のファイルを読む形)/
|
|
723
|
+
**止まり方が変わった0**でした。
|
|
724
|
+
|
|
725
|
+
試験は `scripts/hooks/test_dollar_quote_and_find_file.py`(**116件**)。
|
|
726
|
+
空振り確認は、使い捨ての場所にリポの複製を作り `policy.py` を `9b76b49` に戻して流し、
|
|
727
|
+
**37件が落ちる**ことを確かめています(台本の中にも、判定の部品を旧い形へ差し替える空振りを10件入れてある)。
|
|
728
|
+
|
|
729
|
+
### 分かっている限界
|
|
730
|
+
|
|
731
|
+
- **`-e<語>` のように短い旗へ値を**くっつけた**書き方は、今までどおり読みません**
|
|
732
|
+
(`-e 語` と `--regexp=語` だけ。確かめられた形ではないので触っていません)。
|
|
647
733
|
- **`-f` / `--file` と `-e` が混ざった形では、1つも外しません**(安全側に倒したまま)。
|
|
648
734
|
- **番人が古い機体では効きません。** 各PCで人が1回配布を流すまで、その機では今までどおりです。
|
|
649
735
|
|
package/scripts/hooks/policy.py
CHANGED
|
@@ -662,6 +662,23 @@ def tokens_of(segment: str):
|
|
|
662
662
|
return segment.split()
|
|
663
663
|
|
|
664
664
|
|
|
665
|
+
def naive_token_split(segment) -> bool:
|
|
666
|
+
"""この区切りの語の割り方が【素朴分割へ倒れた】か(便 362a7759)。
|
|
667
|
+
|
|
668
|
+
★tokens_of と同じ判定を同じ道具で行う(=1か所で決める)。倒れたときだけ、
|
|
669
|
+
語に引用符が残る=1つの探す言葉が2語以上に割れていることがある。
|
|
670
|
+
倒れていないとき(shlex が通ったとき)は引用符が剥がされているので、
|
|
671
|
+
探す言葉は必ず1語で閉じている。
|
|
672
|
+
"""
|
|
673
|
+
if not segment:
|
|
674
|
+
return False
|
|
675
|
+
try:
|
|
676
|
+
shlex.split(segment, comments=False, posix=True)
|
|
677
|
+
except ValueError:
|
|
678
|
+
return True
|
|
679
|
+
return False
|
|
680
|
+
|
|
681
|
+
|
|
665
682
|
# 先頭に付く環境設定・ラッパ(実体の動詞まで読み進める)。
|
|
666
683
|
_WRAPPERS = frozenset({
|
|
667
684
|
'env', 'nohup', 'time', 'stdbuf', 'setsid', 'timeout', 'nice', 'ionice',
|
|
@@ -887,7 +904,7 @@ _PATTERN_FLAGS = ('-e', '--regexp')
|
|
|
887
904
|
_PATTERN_FILE_FLAGS = ('-f', '--file')
|
|
888
905
|
|
|
889
906
|
|
|
890
|
-
def _pattern_word_positions(args, first: int, word=None):
|
|
907
|
+
def _pattern_word_positions(args, first: int, word=None, naive: bool = False):
|
|
891
908
|
"""探す文字の語の位置を返す(引用符が壊れて空白で割られた続きも含める)。
|
|
892
909
|
|
|
893
910
|
★word を渡せば、引用符の開き具合をその字面で見る(`--regexp=<探す文字>` のように
|
|
@@ -903,21 +920,27 @@ def _pattern_word_positions(args, first: int, word=None):
|
|
|
903
920
|
パスとして測られ、`.env` で終わって見える語が秘密のファイルに当たって
|
|
904
921
|
読むだけの検索が danger で止まっていた(実地 便 3f54ac4a で便が丸ごと止まった)。
|
|
905
922
|
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
911
|
-
|
|
923
|
+
【どう使うか(便 362a7759 で「割れたか」の見分け方を根本から直した)】
|
|
924
|
+
語の割り方が【素朴分割へ倒れた】ときだけ、開いたままの引用符が閉じるまでの語を
|
|
925
|
+
同じ探す文字の続きとして外す(naive=True)。倒れていないとき(shlex が通ったとき)は
|
|
926
|
+
引用符が剥がされていて探す文字は必ず1語で閉じているので、続きを1つも外さない。
|
|
927
|
+
★見分けるのは「倒れたかどうか」であって「引用符で始まるかどうか」ではない。
|
|
928
|
+
便 18e9e32e は「最初の語が引用符そのもので始まる」を条件にしていたが、これは
|
|
929
|
+
① `$'…'` のように引用符で始まらない書き方(実測 この便の形A)では続きを外せず、
|
|
930
|
+
割れた2語目がパスとして測られて読むだけの検索が danger で止まり、
|
|
931
|
+
② 逆に、割れていないのに語の【途中】に引用符が1つ在る形(`-n "'" <秘密のファイル>`)では
|
|
932
|
+
続きを外してしまい、名指しの秘密のファイルまで探す文字として読み飛ばしていた
|
|
933
|
+
(実測 この便の重大発見2=止める側の穴)。
|
|
934
|
+
「倒れたかどうか」で見ると①②が同時に正しくなる(探す言葉の【途中】に引用符が1つ入る形
|
|
935
|
+
`-rn "it's" <フォルダ>` は shlex が通る=倒れていないので、今までどおり続きを外さない)。
|
|
912
936
|
★止める側は1件も減らない:クォートが壊れた切れ端は、同じ命令を本物の区切り
|
|
913
937
|
(split_commands・引用符を守る割り方)でも必ず測り直す(_real_segments・便 2.5)ので、
|
|
914
938
|
`<検索の道具> -n 'a\\|b' <秘密のファイル>` のような形は、そちらで今までどおり止まる。
|
|
915
|
-
★引用符が壊れていない(=語の割り方が正しい)ときは、最初の1語だけを外す
|
|
916
|
-
=これまでと同じ振る舞い。
|
|
917
939
|
"""
|
|
918
940
|
out = [first]
|
|
919
941
|
word = args[first] if word is None else word
|
|
920
|
-
if
|
|
942
|
+
if not naive:
|
|
943
|
+
# 語の割り方が正しかった=引用符は剥がされている。探す文字はこの1語で閉じている。
|
|
921
944
|
return out
|
|
922
945
|
quote = _open_quote(word)
|
|
923
946
|
i = first + 1
|
|
@@ -928,14 +951,18 @@ def _pattern_word_positions(args, first: int, word=None):
|
|
|
928
951
|
return out
|
|
929
952
|
|
|
930
953
|
|
|
931
|
-
def pattern_arg_positions(verb: str, args):
|
|
954
|
+
def pattern_arg_positions(verb: str, args, seg=None):
|
|
932
955
|
"""探す文字として扱う引数の位置を【全部】返す(無ければ空)。
|
|
933
956
|
|
|
934
957
|
★ここで返した位置だけをパスの判定から外す。それ以外は今までどおり全部測る。
|
|
935
958
|
★外すのは「探す文字」だけ:名指しのパス(-f / --file の値を含む)は1つも外さない。
|
|
959
|
+
★seg(測っている区切りの字面)を渡すと、語の割り方が素朴分割へ倒れたかを見て、
|
|
960
|
+
割れた探す言葉の続きも外す(便 362a7759)。渡さなければ続きを1つも外さない
|
|
961
|
+
=パスとして測る側が増える安全側。
|
|
936
962
|
"""
|
|
937
963
|
if verb not in _PATTERN_FIRST_VERBS:
|
|
938
964
|
return frozenset()
|
|
965
|
+
naive = naive_token_split(seg)
|
|
939
966
|
out = set()
|
|
940
967
|
explicit = False
|
|
941
968
|
i, n = 0, len(args)
|
|
@@ -948,20 +975,20 @@ def pattern_arg_positions(verb: str, args):
|
|
|
948
975
|
explicit = True
|
|
949
976
|
if i + 1 < n:
|
|
950
977
|
# `-e 語` の値は探す文字(パスではない)。値も引用符の壊れで割れることがある。
|
|
951
|
-
out.update(_pattern_word_positions(args, i + 1))
|
|
978
|
+
out.update(_pattern_word_positions(args, i + 1, naive=naive))
|
|
952
979
|
i += 2
|
|
953
980
|
continue
|
|
954
981
|
elif t.startswith('--regexp='):
|
|
955
982
|
explicit = True
|
|
956
983
|
# `--regexp=語` は旗に探す文字が埋まっている(開き具合は `=` の後ろだけで見る)。
|
|
957
|
-
out.update(_pattern_word_positions(args, i, t.split('=', 1)[1]))
|
|
984
|
+
out.update(_pattern_word_positions(args, i, t.split('=', 1)[1], naive=naive))
|
|
958
985
|
i += 1
|
|
959
986
|
if explicit:
|
|
960
987
|
return frozenset(out) # 探す文字は旗で示されている=最初の引数はパス
|
|
961
988
|
first = next((p for p, t in enumerate(args) if not t.startswith('-')), -1)
|
|
962
989
|
if first < 0:
|
|
963
990
|
return frozenset()
|
|
964
|
-
return frozenset(_pattern_word_positions(args, first))
|
|
991
|
+
return frozenset(_pattern_word_positions(args, first, naive=naive))
|
|
965
992
|
|
|
966
993
|
|
|
967
994
|
# 「中身を読み出す」動詞(秘密に対して使われたら露出)。
|
|
@@ -1628,7 +1655,7 @@ def _recursive_read_danger(verb: str, tokens, cwd=None, seg=None):
|
|
|
1628
1655
|
else:
|
|
1629
1656
|
return None
|
|
1630
1657
|
patterns = _search_excludes(args)
|
|
1631
|
-
skips = pattern_arg_positions(verb, args) # 探す文字は【全部】パスの判定から外す
|
|
1658
|
+
skips = pattern_arg_positions(verb, args, seg) # 探す文字は【全部】パスの判定から外す
|
|
1632
1659
|
roots = []
|
|
1633
1660
|
files = []
|
|
1634
1661
|
named = 0
|
|
@@ -1673,7 +1700,13 @@ def _recursive_read_danger(verb: str, tokens, cwd=None, seg=None):
|
|
|
1673
1700
|
|
|
1674
1701
|
|
|
1675
1702
|
def _find_feed_danger(command: str, cwd=None):
|
|
1676
|
-
"""`find <場所> -exec cat {}` や `find <場所> | xargs cat` の形で、場所の中に秘密が在れば理由を返す。
|
|
1703
|
+
"""`find <場所> -exec cat {}` や `find <場所> | xargs cat` の形で、場所の中に秘密が在れば理由を返す。
|
|
1704
|
+
|
|
1705
|
+
★名指しの先が【実在のファイル】だけなら、並べられるのはそのファイルだけなので
|
|
1706
|
+
作業場所に倒さない(便 362a7759・便 3be099ba の原因①と同じ考え方=
|
|
1707
|
+
実在が確かめられたときだけ狭める)。その代わり、その段で実在の秘密のファイルを
|
|
1708
|
+
名指ししていれば今までどおり止める(-exec の側に名前を書く形も見る)。
|
|
1709
|
+
"""
|
|
1677
1710
|
low = command
|
|
1678
1711
|
if not re.search(r'\bfind\b', low):
|
|
1679
1712
|
return None
|
|
@@ -1693,12 +1726,27 @@ def _find_feed_danger(command: str, cwd=None):
|
|
|
1693
1726
|
continue
|
|
1694
1727
|
args = toks[1:]
|
|
1695
1728
|
roots = []
|
|
1729
|
+
files = []
|
|
1696
1730
|
for a in args:
|
|
1697
1731
|
if a.startswith('-') or a in ('(', ')', '!'):
|
|
1698
1732
|
break
|
|
1699
1733
|
d = _existing_dir(a, cwd)
|
|
1700
1734
|
if d:
|
|
1701
1735
|
roots.append(d)
|
|
1736
|
+
continue
|
|
1737
|
+
f = _existing_file(a, cwd)
|
|
1738
|
+
if f:
|
|
1739
|
+
files.append(f)
|
|
1740
|
+
if not roots and files:
|
|
1741
|
+
# ★名指しの先が実在のファイルだけ=並べられるのはそのファイルだけなので倒さない。
|
|
1742
|
+
# その段で名指しした実在のファイルが秘密なら、今までどおり止める
|
|
1743
|
+
# (名指しの先そのものと、-exec の側に書いた名前の両方を見る)。
|
|
1744
|
+
for a in args:
|
|
1745
|
+
f = _existing_file(a, cwd)
|
|
1746
|
+
sr = secret_reason(f) if f else None
|
|
1747
|
+
if sr:
|
|
1748
|
+
return f'{sr} read through find'
|
|
1749
|
+
continue
|
|
1702
1750
|
if not roots:
|
|
1703
1751
|
base = cwd if (cwd and os.path.isabs(cwd)) else os.getcwd()
|
|
1704
1752
|
roots = [os.path.realpath(base)]
|
|
@@ -3513,7 +3561,7 @@ def _secret_danger(segment: str, verb: str, tokens, cwd=None):
|
|
|
3513
3561
|
args = tokens[1:] if tokens else []
|
|
3514
3562
|
# ★探す文字(grep の1つ目の引数・-e / --regexp の値・引用符が壊れて割れた続き)は
|
|
3515
3563
|
# パスではないので、パスの判定から外す(便 18e9e32e)。
|
|
3516
|
-
skips = pattern_arg_positions(verb, args)
|
|
3564
|
+
skips = pattern_arg_positions(verb, args, segment)
|
|
3517
3565
|
for pos, raw in enumerate(args):
|
|
3518
3566
|
if pos in skips:
|
|
3519
3567
|
continue
|
|
@@ -5200,6 +5248,16 @@ def _disc_is_whole(target, cwd):
|
|
|
5200
5248
|
return t in wide
|
|
5201
5249
|
|
|
5202
5250
|
|
|
5251
|
+
#: 探す文字(またはそれが書いてあるファイル)を旗で明示する書き方のうち、
|
|
5252
|
+
#: 値を `=` で繋げて1語にした形(`--regexp=語` / `--file=パス`)。
|
|
5253
|
+
#: ★これが在るときも「探す文字は旗で示されている」=旗でない引数はすべて【探す場所】。
|
|
5254
|
+
_DISC_PATTERN_JOINED = ('--regexp=', '--file=')
|
|
5255
|
+
|
|
5256
|
+
|
|
5257
|
+
def _disc_pattern_joined(w) -> bool:
|
|
5258
|
+
return any(w.startswith(p) for p in _DISC_PATTERN_JOINED)
|
|
5259
|
+
|
|
5260
|
+
|
|
5203
5261
|
def _disc_search(words, cwd):
|
|
5204
5262
|
if not words:
|
|
5205
5263
|
return None
|
|
@@ -5220,6 +5278,10 @@ def _disc_search(words, cwd):
|
|
|
5220
5278
|
if w in ('-e', '-f', '--regexp', '--file'):
|
|
5221
5279
|
has_e, skip = True, True
|
|
5222
5280
|
continue
|
|
5281
|
+
if _disc_pattern_joined(w):
|
|
5282
|
+
# `--regexp=語` / `--file=パス` … 探す文字は旗に埋まっている(便 220a1e2c)。
|
|
5283
|
+
has_e = True
|
|
5284
|
+
continue
|
|
5223
5285
|
if w.startswith('-'):
|
|
5224
5286
|
continue
|
|
5225
5287
|
pos.append(w)
|
|
@@ -5235,6 +5297,10 @@ def _disc_search(words, cwd):
|
|
|
5235
5297
|
if w in ('-e', '-f', '--regexp', '--file'):
|
|
5236
5298
|
has_e, skip = True, True
|
|
5237
5299
|
continue
|
|
5300
|
+
if _disc_pattern_joined(w):
|
|
5301
|
+
# `--regexp=語` / `--file=パス` … 探す文字は旗に埋まっている(便 220a1e2c)。
|
|
5302
|
+
has_e = True
|
|
5303
|
+
continue
|
|
5238
5304
|
if w in ('--max-depth', '-d', '--depth'):
|
|
5239
5305
|
depth, skip = 'next', True
|
|
5240
5306
|
continue
|