feat(mosaic): vetted user store — mosaic store add|list (W-F4)
First command over the USER data root (~/.mosaic), per the HARNESS-HOMES two-root split: ~/.config/mosaic is update-owned system space; ~/.mosaic is user content that installs/updates never touch. The store is the vetting boundary for plugins and skills. - commands/store.ts: store add <kind> <name> <version> --from <dir> --by <operator> [--notes] — copies real directory content (symlinks refused, source must be outside the store) into <root>/<kind>s/<name>/<version>/ and writes store-entry.json LAST, so a partial write can never list as a usable entry (a markerless dir is reclaimed with status recovered-partial; an existing marker makes add append-only-refusing). store list [--kind] [--name] — deterministic enumeration with typed statuses: vetted | incomplete | invalid-metadata | foreign (surfaced, never mutated). - Name/version validated before any filesystem call; rich status enum over booleans; env seam MOSAIC_USER_HOME for tests — modelled on skill.ts, pointed at the user root instead of the system root. - constants: DEFAULT_MOSAIC_USER_HOME. cli.ts: registration only. - store.spec.ts: 45 tests — validation matrix, marker-last/append-only semantics, symlink refusal (source link and nested), self-copy guard, partial recovery, listing classification, CLI exit codes. Gates (worktree, sb-it-1-dt): store spec 45/45; package build+typecheck+lint green; package pnpm test vitest 87 files/1593 tests green — framework-shell chain stops at invariant_r (host pi 0.84.2 vs recorded 0.84.1, inherited); root build 25/25 + typecheck 45/45; prettier clean (diff-scanned). Deferred to W-F6: activation/symlink-install into agent homes, version pinning, network acquisition (add is local-path only, by design).
This commit is contained in:
fargo
@@ -0,0 +1,518 @@
|
||||
import {
|
||||
cpSync,
|
||||
existsSync,
|
||||
lstatSync,
|
||||
mkdirSync,
|
||||
readdirSync,
|
||||
readFileSync,
|
||||
rmSync,
|
||||
writeFileSync,
|
||||
type Dirent,
|
||||
type Stats,
|
||||
} from 'node:fs';
|
||||
import { isAbsolute, join, parse, relative, resolve, sep } from 'node:path';
|
||||
import type { Command } from 'commander';
|
||||
import { DEFAULT_MOSAIC_USER_HOME } from '../constants.js';
|
||||
|
||||
/**
|
||||
* `mosaic store` — the vetted user store under `~/.mosaic/{plugins,skills}` (W-F4).
|
||||
*
|
||||
* Two roots with distinct ownership (HARNESS-HOMES design, frozen REV3):
|
||||
* - `~/.config/mosaic/` is the SYSTEM root: update-owned, replaceable wholesale.
|
||||
* - `~/.mosaic/` is the USER root: never touched by installs or updates.
|
||||
*
|
||||
* This module only ever writes under the USER root. The store is the vetting
|
||||
* boundary: content lands here only through an explicit `store add` carrying a
|
||||
* named vetting attribution, and every entry is versioned
|
||||
* (`store/<kind>s/<name>/<version>/`) with a `store-entry.json` marker written
|
||||
* LAST — a version directory without its marker is a partial write, never a
|
||||
* usable entry.
|
||||
*
|
||||
* Deferred by design (W-F6 and later): activation/symlink-install into agent
|
||||
* homes, `current`-pointer pinning, network acquisition. `add` accepts a local
|
||||
* source path only — no network, no credentials, ever.
|
||||
*/
|
||||
|
||||
export type StoreKind = 'plugin' | 'skill';
|
||||
export const STORE_KINDS: readonly StoreKind[] = ['plugin', 'skill'];
|
||||
|
||||
/** On-disk metadata marker; written last so its presence commits an entry. */
|
||||
export const STORE_ENTRY_MARKER = 'store-entry.json';
|
||||
|
||||
export interface StorePaths {
|
||||
/** User data root, e.g. `~/.mosaic`. */
|
||||
userRoot: string;
|
||||
}
|
||||
|
||||
export interface StoreEntryMeta {
|
||||
schema: 1;
|
||||
kind: StoreKind;
|
||||
name: string;
|
||||
version: string;
|
||||
/** Absolute source path the content was vetted from, as resolved at add time. */
|
||||
sourcePath: string;
|
||||
/** Operator who vouched for the content — required, non-empty. */
|
||||
vettedBy: string;
|
||||
/** ISO timestamp of the add. */
|
||||
vettedAt: string;
|
||||
/** Free-form vetting notes, if any. */
|
||||
notes?: string;
|
||||
}
|
||||
|
||||
export type StoreAddStatus = 'added' | 'recovered-partial';
|
||||
|
||||
export interface StoreAddResult {
|
||||
kind: StoreKind;
|
||||
name: string;
|
||||
version: string;
|
||||
status: StoreAddStatus;
|
||||
entryPath: string;
|
||||
sourcePath: string;
|
||||
}
|
||||
|
||||
export type StoreEntryStatus = 'vetted' | 'incomplete' | 'invalid-metadata' | 'foreign';
|
||||
|
||||
export interface StoreListEntry {
|
||||
kind: StoreKind;
|
||||
name: string;
|
||||
/** Undefined for name-level foreign files (not a directory at all). */
|
||||
version?: string;
|
||||
status: StoreEntryStatus;
|
||||
entryPath: string;
|
||||
meta?: StoreEntryMeta;
|
||||
}
|
||||
|
||||
const SAFE_STORE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
|
||||
const SAFE_STORE_VERSION = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
|
||||
|
||||
export class StoreError extends Error {
|
||||
public readonly code: string;
|
||||
|
||||
public constructor(code: string, message: string) {
|
||||
super(message);
|
||||
this.name = 'StoreError';
|
||||
this.code = code;
|
||||
}
|
||||
}
|
||||
|
||||
/** Resolve the user store root while keeping tests injectable. */
|
||||
export function getDefaultStorePaths(): StorePaths {
|
||||
const userRoot = process.env['MOSAIC_USER_HOME'] ?? DEFAULT_MOSAIC_USER_HOME;
|
||||
return { userRoot };
|
||||
}
|
||||
|
||||
/**
|
||||
* Reject a user-supplied name before any filesystem operation.
|
||||
* A store name identifies one directory under `store/<kind>s/`.
|
||||
*/
|
||||
export function validateStoreName(name: string): void {
|
||||
if (
|
||||
name.length === 0 ||
|
||||
name.startsWith('-') ||
|
||||
name.endsWith('.') ||
|
||||
name.includes('..') ||
|
||||
name.includes('/') ||
|
||||
name.includes('\\') ||
|
||||
isAbsolute(name) ||
|
||||
!SAFE_STORE_NAME.test(name)
|
||||
) {
|
||||
throw new StoreError(
|
||||
'STORE_INVALID_NAME',
|
||||
`Invalid store name ${JSON.stringify(name)}: use letters, numbers, dots, underscores, or hyphens; start with a letter or number; and do not use paths, "..", or a leading "-".`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/** Versions share the name discipline plus `+` (semver build metadata). */
|
||||
export function validateStoreVersion(version: string): void {
|
||||
if (
|
||||
version.length === 0 ||
|
||||
version.startsWith('-') ||
|
||||
version.endsWith('.') ||
|
||||
version.includes('..') ||
|
||||
version.includes('/') ||
|
||||
version.includes('\\') ||
|
||||
isAbsolute(version) ||
|
||||
!SAFE_STORE_VERSION.test(version)
|
||||
) {
|
||||
throw new StoreError(
|
||||
'STORE_INVALID_VERSION',
|
||||
`Invalid version ${JSON.stringify(version)}: use letters, numbers, dots, underscores, hyphens, or plus; start with a letter or number; and do not use paths, "..", or a leading "-".`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
export function validateStoreKind(kind: string): asserts kind is StoreKind {
|
||||
if (!(STORE_KINDS as readonly string[]).includes(kind)) {
|
||||
throw new StoreError(
|
||||
'STORE_INVALID_KIND',
|
||||
`Invalid store kind ${JSON.stringify(kind)}: expected one of ${STORE_KINDS.map((k) => `"${k}"`).join(', ')}.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function validateVettedBy(vettedBy: string): void {
|
||||
if (vettedBy.trim().length === 0 || vettedBy.includes('\n') || vettedBy.length > 80) {
|
||||
throw new StoreError(
|
||||
'STORE_INVALID_VETTER',
|
||||
'Invalid --by value: name the operator vouching for this content (single line, at most 80 characters).',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function lstatIfPresent(path: string): Stats | undefined {
|
||||
try {
|
||||
return lstatSync(path);
|
||||
} catch (error: unknown) {
|
||||
if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return undefined;
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
function assertNoSymlinkAncestors(path: string): void {
|
||||
const absolute = resolve(path);
|
||||
const pathRoot = parse(absolute).root;
|
||||
let current = pathRoot;
|
||||
|
||||
for (const segment of relative(pathRoot, absolute).split(sep)) {
|
||||
if (segment.length === 0) continue;
|
||||
current = join(current, segment);
|
||||
const entry = lstatIfPresent(current);
|
||||
if (!entry) break;
|
||||
if (entry.isSymbolicLink()) {
|
||||
throw new StoreError(
|
||||
'STORE_SYMLINK_ROOT',
|
||||
`Refusing symlink ancestor at ${current}; the user store root must resolve without symlink traversal.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** `plugins` for plugin, `skills` for skill — plural on disk per the layout. */
|
||||
function kindDirName(kind: StoreKind): string {
|
||||
return kind === 'plugin' ? 'plugins' : 'skills';
|
||||
}
|
||||
|
||||
export function storeKindDir(kind: StoreKind, paths: StorePaths = getDefaultStorePaths()): string {
|
||||
return join(paths.userRoot, kindDirName(kind));
|
||||
}
|
||||
|
||||
function entryDir(kind: StoreKind, name: string, version: string, paths: StorePaths): string {
|
||||
return join(storeKindDir(kind, paths), name, version);
|
||||
}
|
||||
|
||||
function isInsideRoot(candidate: string, root: string): boolean {
|
||||
const rel = relative(resolve(root), resolve(candidate));
|
||||
return rel.length > 0 && rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
|
||||
}
|
||||
|
||||
/**
|
||||
* Refuse any symlink in the source tree — the vetting boundary copies real
|
||||
* content only, so a vetted entry can never carry a link that escapes it.
|
||||
*/
|
||||
function assertSourceTreeHasNoSymlinks(sourcePath: string): void {
|
||||
const stack: string[] = [sourcePath];
|
||||
while (stack.length > 0) {
|
||||
const current = stack.pop()!;
|
||||
for (const dirent of readdirSync(current, { withFileTypes: true })) {
|
||||
const child = join(current, dirent.name);
|
||||
if (dirent.isSymbolicLink()) {
|
||||
throw new StoreError(
|
||||
'STORE_SOURCE_SYMLINK',
|
||||
`Refusing to vet content containing a symlink: ${child}. Resolve or remove symlinks before adding to the store.`,
|
||||
);
|
||||
}
|
||||
if (dirent.isDirectory()) stack.push(child);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Vet and add one versioned entry to the user store.
|
||||
*
|
||||
* Copies the source directory (real content, no symlinks) to
|
||||
* `<userRoot>/<kind>s/<name>/<version>/` and writes the `store-entry.json`
|
||||
* marker LAST: a crash mid-copy leaves at most a recoverable partial, never a
|
||||
* half-vetted entry that lists as present.
|
||||
*/
|
||||
export function addStoreEntry(
|
||||
kind: StoreKind,
|
||||
name: string,
|
||||
version: string,
|
||||
sourcePath: string,
|
||||
vettedBy: string,
|
||||
notes: string | undefined,
|
||||
paths: StorePaths = getDefaultStorePaths(),
|
||||
): StoreAddResult {
|
||||
validateStoreKind(kind);
|
||||
validateStoreName(name);
|
||||
validateStoreVersion(version);
|
||||
validateVettedBy(vettedBy);
|
||||
assertNoSymlinkAncestors(paths.userRoot);
|
||||
|
||||
const resolvedSource = resolve(sourcePath);
|
||||
const source = lstatIfPresent(resolvedSource);
|
||||
if (!source) {
|
||||
throw new StoreError('STORE_SOURCE_MISSING', `Source path does not exist: ${resolvedSource}`);
|
||||
}
|
||||
if (source.isSymbolicLink()) {
|
||||
throw new StoreError(
|
||||
'STORE_SOURCE_SYMLINK',
|
||||
`Refusing to vet a symlink as store content: ${resolvedSource} (points at ${resolve(sourcePath)}). Add the real directory.`,
|
||||
);
|
||||
}
|
||||
if (!source.isDirectory()) {
|
||||
throw new StoreError(
|
||||
'STORE_SOURCE_NOT_DIR',
|
||||
`Source path is not a directory: ${resolvedSource}`,
|
||||
);
|
||||
}
|
||||
if (isInsideRoot(resolvedSource, paths.userRoot)) {
|
||||
throw new StoreError(
|
||||
'STORE_SOURCE_INSIDE_STORE',
|
||||
`Refusing to add store content from inside the store itself: ${resolvedSource}`,
|
||||
);
|
||||
}
|
||||
assertSourceTreeHasNoSymlinks(resolvedSource);
|
||||
|
||||
const target = entryDir(kind, name, version, paths);
|
||||
const existing = lstatIfPresent(target);
|
||||
let status: StoreAddStatus = 'added';
|
||||
if (existing) {
|
||||
if (existsSync(join(target, STORE_ENTRY_MARKER))) {
|
||||
throw new StoreError(
|
||||
'STORE_ALREADY_PRESENT',
|
||||
`${kind} "${name}" version "${version}" is already present at ${target}; stores are append-only — add a new version instead.`,
|
||||
);
|
||||
}
|
||||
// Partial write (no marker): safe to reclaim.
|
||||
rmSync(target, { recursive: true, force: true });
|
||||
status = 'recovered-partial';
|
||||
}
|
||||
|
||||
mkdirSync(target, { recursive: true });
|
||||
cpSync(resolvedSource, target, { recursive: true });
|
||||
|
||||
const meta: StoreEntryMeta = {
|
||||
schema: 1,
|
||||
kind,
|
||||
name,
|
||||
version,
|
||||
sourcePath: resolvedSource,
|
||||
vettedBy: vettedBy.trim(),
|
||||
vettedAt: new Date().toISOString(),
|
||||
...(notes === undefined ? {} : { notes }),
|
||||
};
|
||||
writeFileSync(join(target, STORE_ENTRY_MARKER), `${JSON.stringify(meta, null, 2)}\n`);
|
||||
|
||||
return { kind, name, version, status, entryPath: target, sourcePath: resolvedSource };
|
||||
}
|
||||
|
||||
function readEntryMeta(markerPath: string): { meta?: StoreEntryMeta; status: StoreEntryStatus } {
|
||||
let raw: string;
|
||||
try {
|
||||
raw = readFileSync(markerPath, 'utf-8');
|
||||
} catch {
|
||||
return { status: 'invalid-metadata' };
|
||||
}
|
||||
try {
|
||||
const parsed = JSON.parse(raw) as StoreEntryMeta;
|
||||
if (
|
||||
parsed?.schema === 1 &&
|
||||
(STORE_KINDS as readonly string[]).includes(parsed.kind) &&
|
||||
typeof parsed.name === 'string' &&
|
||||
typeof parsed.version === 'string' &&
|
||||
typeof parsed.vettedBy === 'string' &&
|
||||
typeof parsed.vettedAt === 'string'
|
||||
) {
|
||||
return { meta: parsed, status: 'vetted' };
|
||||
}
|
||||
} catch {
|
||||
// fall through
|
||||
}
|
||||
return { status: 'invalid-metadata' };
|
||||
}
|
||||
|
||||
/**
|
||||
* Enumerate every store entry deterministically (kind, then name, then
|
||||
* version). Version directories without a marker list as `incomplete`; files
|
||||
* where directories were expected list as `foreign` — surfaced, never mutated.
|
||||
*/
|
||||
export function listStoreEntries(
|
||||
paths: StorePaths = getDefaultStorePaths(),
|
||||
filter: { kind?: StoreKind; name?: string } = {},
|
||||
): StoreListEntry[] {
|
||||
if (filter.name !== undefined) validateStoreName(filter.name);
|
||||
assertNoSymlinkAncestors(paths.userRoot);
|
||||
|
||||
const kinds = filter.kind ? [filter.kind] : [...STORE_KINDS];
|
||||
const entries: StoreListEntry[] = [];
|
||||
|
||||
for (const kind of kinds) {
|
||||
const kindRoot = lstatIfPresent(storeKindDir(kind, paths));
|
||||
if (!kindRoot) continue;
|
||||
if (!kindRoot.isDirectory()) {
|
||||
entries.push({
|
||||
kind,
|
||||
name: kindDirName(kind),
|
||||
status: 'foreign',
|
||||
entryPath: storeKindDir(kind, paths),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
for (const nameDirent of readdirSync(storeKindDir(kind, paths), {
|
||||
withFileTypes: true,
|
||||
}).sort(byName) as Dirent[]) {
|
||||
if (filter.name !== undefined && nameDirent.name !== filter.name) continue;
|
||||
const namePath = join(storeKindDir(kind, paths), nameDirent.name);
|
||||
|
||||
if (!nameDirent.isDirectory()) {
|
||||
entries.push({ kind, name: nameDirent.name, status: 'foreign', entryPath: namePath });
|
||||
continue;
|
||||
}
|
||||
|
||||
const versionDirents = readdirSync(namePath, { withFileTypes: true }).sort(byName);
|
||||
if (versionDirents.length === 0) {
|
||||
entries.push({ kind, name: nameDirent.name, status: 'incomplete', entryPath: namePath });
|
||||
continue;
|
||||
}
|
||||
for (const versionDirent of versionDirents) {
|
||||
const versionPath = join(namePath, versionDirent.name);
|
||||
if (!versionDirent.isDirectory()) {
|
||||
entries.push({
|
||||
kind,
|
||||
name: nameDirent.name,
|
||||
version: versionDirent.name,
|
||||
status: 'foreign',
|
||||
entryPath: versionPath,
|
||||
});
|
||||
continue;
|
||||
}
|
||||
const markerPath = join(versionPath, STORE_ENTRY_MARKER);
|
||||
if (!existsSync(markerPath)) {
|
||||
entries.push({
|
||||
kind,
|
||||
name: nameDirent.name,
|
||||
version: versionDirent.name,
|
||||
status: 'incomplete',
|
||||
entryPath: versionPath,
|
||||
});
|
||||
continue;
|
||||
}
|
||||
const { meta, status } = readEntryMeta(markerPath);
|
||||
entries.push({
|
||||
kind,
|
||||
name: nameDirent.name,
|
||||
version: versionDirent.name,
|
||||
status,
|
||||
entryPath: versionPath,
|
||||
...(meta === undefined ? {} : { meta }),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return entries;
|
||||
}
|
||||
|
||||
function byName(a: Dirent, b: Dirent): number {
|
||||
return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
|
||||
}
|
||||
|
||||
function reportCommandError(error: unknown): void {
|
||||
if (error instanceof StoreError) {
|
||||
console.error(`store: ${error.code}: ${error.message}`);
|
||||
} else {
|
||||
console.error(error instanceof Error ? error.message : String(error));
|
||||
}
|
||||
process.exitCode = 1;
|
||||
}
|
||||
|
||||
function displayStoreName(name: string): string {
|
||||
return SAFE_STORE_NAME.test(name) ? name : JSON.stringify(name);
|
||||
}
|
||||
|
||||
/** Register the `mosaic store` command group (W-F4). */
|
||||
export function registerStoreCommand(
|
||||
program: Command,
|
||||
paths: StorePaths = getDefaultStorePaths(),
|
||||
): void {
|
||||
const store = program
|
||||
.command('store')
|
||||
.description('Manage the vetted user store under ~/.mosaic (plugins, skills)')
|
||||
.configureHelp({ sortSubcommands: true });
|
||||
|
||||
store
|
||||
.command('add <kind> <name> <version>')
|
||||
.description(
|
||||
'Vet and add a local plugin/skill directory to the user store (versioned, append-only)',
|
||||
)
|
||||
.requiredOption('--from <path>', 'Local source directory to vet (no network acquisition)')
|
||||
.requiredOption('--by <operator>', 'Name of the operator vouching for this content')
|
||||
.option('--notes <notes>', 'Vetting notes recorded in the entry metadata')
|
||||
.action(
|
||||
async (
|
||||
kind: string,
|
||||
name: string,
|
||||
version: string,
|
||||
opts: {
|
||||
from: string;
|
||||
by: string;
|
||||
notes?: string;
|
||||
},
|
||||
) => {
|
||||
try {
|
||||
const result = addStoreEntry(
|
||||
kind as StoreKind,
|
||||
name,
|
||||
version,
|
||||
opts.from,
|
||||
opts.by,
|
||||
opts.notes,
|
||||
paths,
|
||||
);
|
||||
const suffix = result.status === 'recovered-partial' ? ' (recovered partial write)' : '';
|
||||
console.log(
|
||||
`${result.kind} ${displayStoreName(result.name)} ${result.version}: added${suffix}`,
|
||||
);
|
||||
console.log(` entry: ${result.entryPath}`);
|
||||
console.log(` vetted by ${opts.by.trim()}`);
|
||||
} catch (error: unknown) {
|
||||
reportCommandError(error);
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
store
|
||||
.command('list')
|
||||
.description('List store entries with vetting status')
|
||||
.option('--kind <kind>', 'Filter by kind (plugin | skill)')
|
||||
.option('--name <name>', 'Filter by entry name')
|
||||
.action((opts: { kind?: string; name?: string }) => {
|
||||
try {
|
||||
let kind: StoreKind | undefined;
|
||||
if (opts.kind !== undefined) {
|
||||
validateStoreKind(opts.kind);
|
||||
kind = opts.kind;
|
||||
}
|
||||
const entries = listStoreEntries(paths, {
|
||||
...(kind === undefined ? {} : { kind }),
|
||||
...(opts.name === undefined ? {} : { name: opts.name }),
|
||||
});
|
||||
if (entries.length === 0) {
|
||||
console.log('No store entries found.');
|
||||
return;
|
||||
}
|
||||
for (const entry of entries) {
|
||||
const version = entry.version ?? '-';
|
||||
const vetter = entry.meta?.vettedBy ?? '-';
|
||||
console.log(
|
||||
`${entry.status.padEnd(17)}${entry.kind.padEnd(8)}${displayStoreName(entry.name).padEnd(24)}${version.padEnd(16)}${vetter}`,
|
||||
);
|
||||
}
|
||||
} catch (error: unknown) {
|
||||
reportCommandError(error);
|
||||
}
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user