@entrorove/skill 0.1.36 → 0.1.38

package/snapshot-cleanup-journal.mjs

@@ -0,0 +1,32 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { atomicMutationJson14, readMutationJson14, privateMutationDirectory14, cleanupMutationDirectory14 } from './local-mutation-files.mjs';
+
+const absent = cause => { if (cause.code !== 'ENOENT') throw cause; return null; };
+export async function resumeSnapshotRemoval(file, directory, flowId) {
+  if (!await fs.lstat(file).catch(absent)) return null;
+  const saved = await readMutationJson14(file);
+  if (saved.schemaVersion !== 'entrorove.snapshot-removal/1.0' || saved.flowId !== flowId
+    || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(saved.snapshotId ?? '')
+    || !/^cleanup-[a-f0-9-]{36}$/u.test(saved.quarantine ?? '')
+    || !Number.isSafeInteger(saved.bytes) || saved.bytes < 0) throw new Error('Unknown snapshot cleanup journal was preserved');
+  const source = path.join(directory, saved.snapshotId), quarantine = path.join(directory, saved.quarantine);
+  const original = await fs.lstat(source).catch(absent), moved = await fs.lstat(quarantine).catch(absent);
+  if (original && moved) throw new Error('Snapshot cleanup cannot remove two competing directories');
+  const stat = original ?? moved;
+  if (stat && (!stat.isDirectory() || stat.isSymbolicLink() || String(stat.dev) !== saved.device || String(stat.ino) !== saved.inode)) {
+    throw new Error('Snapshot cleanup refuses a substituted directory');
+  }
+  if (original) await fs.rename(source, quarantine);
+  if (stat) await cleanupMutationDirectory14(await privateMutationDirectory14(quarantine));
+  await fs.unlink(file);
+  return { name: saved.snapshotId, bytes: saved.bytes };
+}
+export async function removeSnapshotWithJournal(file, directory, flowId, record) {
+  const stat = await fs.lstat(path.join(directory, record.name));
+  await atomicMutationJson14(file, { schemaVersion: 'entrorove.snapshot-removal/1.0', flowId,
+    snapshotId: record.name, quarantine: `cleanup-${randomUUID()}`, bytes: record.bytes,
+    device: String(stat.dev), inode: String(stat.ino) });
+  return resumeSnapshotRemoval(file, directory, flowId);
+}

package/snapshot-retention.mjs

@@ -0,0 +1,95 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { canonical, sha256, verifySnapshotManifest } from './local-integrity.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { mutationStateRoot14, atomicMutationJson14, privateMutationDirectory14 } from './local-mutation-files.mjs';
+import { resumeSnapshotRemoval, removeSnapshotWithJournal } from './snapshot-cleanup-journal.mjs';
+
+const id = value => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+async function realDirectory(directory) {
+  const stat = await fs.lstat(directory).catch(cause => { if (cause.code !== 'ENOENT') throw cause; return null; });
+  if (!stat) return false;
+  if (!stat.isDirectory() || stat.isSymbolicLink() || process.platform !== 'win32' && stat.uid !== process.getuid()) throw new Error('Snapshot cleanup requires an owned real directory');
+  return true;
+}
+async function safeTree(directory) {
+  let bytes = 0;
+  for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+    const file = path.join(directory, entry.name), stat = await fs.lstat(file);
+    if (stat.isSymbolicLink() || stat.nlink > 1 && !stat.isDirectory() || process.platform !== 'win32' && stat.uid !== process.getuid()) throw new Error('Snapshot cleanup preserves unknown links or ownership');
+    if (stat.isDirectory()) bytes += await safeTree(file);
+    else if (stat.isFile()) bytes += stat.size;
+    else throw new Error('Snapshot cleanup preserves unknown filesystem entries');
+  }
+  return bytes;
+}
+function completedProof(call, result) {
+  if (call.operation !== 'continue' || call.input?.operation !== 'workflow-verdict' || !id(call.input.flowId)) return null;
+  const output = result?.output, receipt = result?.feedback;
+  const reports = output?.result?.reports ?? output?.reports;
+  if (output?.status !== 'succeeded' || output.flowId !== call.input.flowId || !Array.isArray(reports) || !reports.length
+    || reports.some(report => !['pass','pass-with-risk'].includes(report.verdict)) || receipt?.requestId !== output.requestId
+    || receipt.resultDigest !== sha256(canonical(output)) || receipt.evaluation?.disposition !== 'good'
+    || receipt.evaluation.validation !== 'passed' || receipt.acknowledgement?.stored !== true) return null;
+  return { flowId: output.flowId, requestId: output.requestId, receiptId: receipt.receiptId, evaluationDigest: receipt.evaluation.digest };
+}
+async function protectedSnapshots(root, repository, flowId) {
+  const target = path.join(root, 'scope', repository, flowId, 'state.json');
+  const stat = await fs.lstat(target).catch(cause => { if (cause.code !== 'ENOENT') throw cause; return null; });
+  if (!stat) return new Set();
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16 * 1024 * 1024) throw new Error('Unknown scope binding was preserved');
+  const state = JSON.parse(await fs.readFile(target, 'utf8'));
+  return new Set([state.originalSnapshot?.snapshotId, state.snapshotId].filter(id));
+}
+async function cleanupRepository(root, repository, proof) {
+  const directory = path.join(root, 'snapshots', repository, proof.flowId);
+  if (!await realDirectory(directory)) return { removed: [], retained: [], releasedBytes: 0 };
+  const journal = path.join(root, 'snapshot-cleanup', `${sha256(`${repository}:${proof.flowId}`)}-pending.json`);
+  const resumed = await resumeSnapshotRemoval(journal, directory, proof.flowId);
+  const records = [], protectedIds = await protectedSnapshots(root, repository, proof.flowId);
+  for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.isSymbolicLink() || !id(entry.name)) continue;
+    const snapshot = path.join(directory, entry.name), manifestPath = path.join(snapshot, 'manifest.json');
+    const stat = await fs.lstat(manifestPath).catch(cause => { if (cause.code !== 'ENOENT') throw cause; return null; });
+    if (!stat?.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 1_000_000
+      || process.platform !== 'win32' && (stat.uid !== process.getuid() || stat.mode & 0o077)) continue;
+    const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+    if (!Number.isFinite(Date.parse(manifest.createdAt))) continue;
+    if (!verifySnapshotManifest(manifest, { snapshotId: entry.name, flowId: proof.flowId, stepId: manifest.stepId, repositoryDigest: repository }).verified) continue;
+    records.push({ name: entry.name, stepId: manifest.stepId, time: Date.parse(manifest.createdAt), bytes: await safeTree(snapshot) });
+  }
+  // Preserve the original rollback image and final image for each real step,
+  // including the still-referenced origin snapshot. Superseded copies are freed.
+  const retained = new Set(protectedIds);
+  for (const step of new Set(records.map(record => record.stepId))) {
+    const ordered = records.filter(record => record.stepId === step).sort((a, b) => a.time - b.time || a.name.localeCompare(b.name));
+    retained.add(ordered[0].name); retained.add(ordered.at(-1).name);
+  }
+  const removed = resumed ? [resumed.name] : []; let releasedBytes = resumed?.bytes ?? 0;
+  for (const record of records) if (!retained.has(record.name)) {
+    await removeSnapshotWithJournal(journal, directory, proof.flowId, record);
+    removed.push(record.name); releasedBytes += record.bytes;
+  }
+  return { removed, retained: [...retained].sort(), releasedBytes };
+}
+export async function cleanupCompletedSnapshots(call, result, { home = os.homedir() } = {}) {
+  const proof = completedProof(call, result);
+  if (!proof) return { status: 'preserved', reason: 'verified-original-completion-required' };
+  const root = await mutationStateRoot14({ home }), snapshotRoot = path.join(root, 'snapshots');
+  if (!await realDirectory(snapshotRoot)) return { status: 'completed', removed: 0, releasedBytes: 0 };
+  const records = [], recordDirectory = path.join(root, 'snapshot-cleanup');
+  await privateMutationDirectory14(recordDirectory);
+  const receiptPath = path.join(recordDirectory, `${sha256(proof.flowId)}.json`);
+  return withStateLock(receiptPath, async () => {
+    for (const entry of await fs.readdir(snapshotRoot, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.isSymbolicLink() && /^[a-f0-9]{32}$/u.test(entry.name)) records.push({ repositoryDigest: entry.name,
+        ...await cleanupRepository(root, entry.name, proof) });
+    }
+    const receipt = { schemaVersion: 'entrorove.snapshot-cleanup/1.0', status: 'completed', ...proof, records,
+      removed: records.reduce((sum, item) => sum + item.removed.length, 0), releasedBytes: records.reduce((sum, item) => sum + item.releasedBytes, 0),
+      observedAt: new Date().toISOString() };
+    await atomicMutationJson14(receiptPath, receipt, { replace: true });
+    return receipt;
+  });
+}

package/task-entry-client.mjs

@@ -0,0 +1,28 @@
+import { requestTransport, parseTransportResponse, trustedOrigin } from './remote-transport.mjs';
+import { runCloudTask } from './cloud-task-client.mjs';
+import { displayIdeEvent, ideClientHeaders, ideTaskIdentity } from './ide-presentation.mjs';
+
+/** New IDE tasks use the authenticated account preference; resumes keep their original route. */
+export async function routeTaskEntry(data, token, dependencies) {
+  if (data.operation !== 'start' || data.input?.sandboxTaskId) return null;
+  const choice = data.sandboxChoice;
+  if (choice !== undefined && !['use','local'].includes(choice)) throw new Error('sandboxChoice must be use or local');
+  if (choice === 'local') {
+    displayIdeEvent({ schemaVersion: 'entrorove.ide-event/1.0',kind: 'status',phase: 'route',
+      message: '本次采用本地方案。',separateLine: true },dependencies.onIdeEvent,{home:dependencies.home});
+    return null;
+  }
+  const response = await requestTransport(trustedOrigin(dependencies.apiOrigin()), '/api/cloud-sandbox', {
+    headers: { authorization: `Bearer ${token}`,...ideClientHeaders() },timeoutMs: 15000,
+  });
+  const preference = parseTransportResponse(response, 'cloud-sandbox preference');
+  if (!response.ok || typeof preference?.enabled !== 'boolean') {
+    throw new Error(`Cloud sandbox preference unavailable: HTTP ${response.status}. Task entry stopped.`);
+  }
+  if (!preference.enabled && choice === undefined) return null;
+  const task = data.input?.task;
+  if (!task || typeof task.goal !== 'string') throw new Error('Task entry requires the original task goal');
+  const ideTaskId = ideTaskIdentity(data.ideTaskId);
+  return runCloudTask({ goal: task.goal, task,
+    ...(ideTaskId ? { ideTaskId } : {}),...(choice ? { sandboxChoice: choice } : {}) },dependencies);
+}

package/task-identity.d.mts

@@ -0,0 +1,2 @@
+export function scopedTaskNumber(identity: string): string;
+export function sandboxTaskNumber(taskId: string): string;

package/task-identity.mjs

@@ -0,0 +1,9 @@
+export function scopedTaskNumber(identity) {
+  let hash = 2166136261;
+  for (const character of identity) {
+    hash ^= character.codePointAt(0) ?? 0;
+    hash = Math.imul(hash, 16777619);
+  }
+  return String((hash >>> 0) % 100000).padStart(5, '0');
+}
+export function sandboxTaskNumber(taskId) { return scopedTaskNumber(`task:${taskId}`); }

package/validator-runtime-build.mjs

@@ -0,0 +1,16 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { resolve } from 'node:path';
+const file = 'validator-runtime-v7.0.44.mjs';
+export async function buildSkillValidator({ checkOnly = false } = {}) {
+  const source = await readFile(resolve(import.meta.dirname, '../../assets', file));
+  const target = resolve(import.meta.dirname, 'runtime', file);
+  if (checkOnly) {
+    const actual = await readFile(target).catch(() => null);
+    if (!actual?.equals(source)) throw new Error('Packaged Validator snapshot differs from the generated source');
+  } else { await mkdir(resolve(import.meta.dirname, 'runtime'), { recursive: true }); await writeFile(target, source); }
+  return { file, sha256: createHash('sha256').update(source).digest('hex') };
+}
+if (process.argv[1] && resolve(process.argv[1]) === resolve(import.meta.filename)) {
+  process.stdout.write(JSON.stringify(await buildSkillValidator({ checkOnly: process.argv.includes('--check') })) + '\n');
+}