harborloop 0.3.0 → 0.4.1

package/dist/index.js

@@ -1,282 +0,0 @@
-#!/usr/bin/env node
-import { realpathSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { runBind, renderBind, NoWorkspaceChosenError, NotARepoError, NotSignedInError, } from './commands/bind.js';
-import { runWorkspaces, renderWorkspaces } from './commands/workspaces.js';
-import { exitCodeForDaemon, renderDaemon, runDaemon } from './commands/daemon.js';
-import { contextToJson, renderContext, runContext } from './commands/context.js';
-import { runDoctor } from './commands/doctor.js';
-import { renderInit, runInit, runLogout } from './commands/init.js';
-import { runStatus } from './commands/status.js';
-import { exitCodeForSync, renderSync, runSync } from './commands/sync.js';
-import { renderToggle, runOff, runOn } from './commands/toggle.js';
-import { renderUnbind, runUnbind } from './commands/unbind.js';
-import { resolveEndpoints } from './endpoints.js';
-import { checksToJson, exitCodeFor, renderChecks } from './render.js';
-export const VERBS = [
-    'init',
-    'login',
-    'logout',
-    'bind',
-    'unbind',
-    'sync',
-    'daemon',
-    'status',
-    'workspaces',
-    'doctor',
-    'context',
-    'on',
-    'off',
-    'help',
-    'version',
-];
-const VALUE_FLAGS = new Set(['workspace', 'project', 'cwd', 'days']);
-export function parseArgs(argv) {
-    const positional = [];
-    const flags = {};
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === '--')
-            continue;
-        if (arg.startsWith('--')) {
-            const [name, ...rest] = arg.slice(2).split('=');
-            if (rest.length > 0) {
-                flags[name] = rest.join('=');
-                continue;
-            }
-            const next = argv[i + 1];
-            if (VALUE_FLAGS.has(name) && next !== undefined && !next.startsWith('-')) {
-                flags[name] = next;
-                i += 1;
-                continue;
-            }
-            flags[name] = true;
-            continue;
-        }
-        if (arg.startsWith('-') && arg.length > 1) {
-            flags[arg.slice(1)] = true;
-            continue;
-        }
-        positional.push(arg);
-    }
-    const first = positional[0];
-    if (first === undefined) {
-        if (flags.version === true || flags.v === true)
-            return { verb: 'version', flags };
-    }
-    if (flags.help === true || flags.h === true)
-        return { verb: 'help', flags };
-    const verb = VERBS.includes(first ?? '')
-        ? first
-        : first === undefined
-            ? 'help'
-            : 'help';
-    if (first !== undefined && !VERBS.includes(first)) {
-        flags.unknownVerb = first;
-    }
-    if (verb === 'bind' && positional[1] && flags.project === undefined) {
-        flags.project = positional[1];
-    }
-    return { verb, flags };
-}
-const USAGE = `harbor — your team's knowledge, in your terminal
-
-  harbor init            sign in, install the hooks, bind this repo, schedule the daemon
-                        (configures the agents it finds;
-                         --codex/--no-codex, --cursor/--no-cursor, --no-daemon)
-  harbor doctor          is it actually working?  (--offline, --json)
-  harbor status          this repo, from local files only
-  harbor context         what this machine pays for on every turn, and who put it there
-                        (--verbose lists every skill, --json)
-  harbor bind [project]  tie this repo to a project
-  harbor workspaces      which workspaces you can reach, and the one this machine uses
-  harbor sync            put this repo's team skills, memories and documents on disk
-                        (no desktop app needed; HARBOR_TOKEN + HARBOR_WORKSPACE_ID for CI)
-  harbor daemon          keep every bound repo AND your own env current, on a timer
-                        (--install to schedule it, --once for one pass, --status)
-  harbor unbind          take those files back off this machine
-                        (local only — the repo stays bound; files you edited stay put)
-  harbor off             pause this repo   (--capture keeps recall, --global)
-  harbor on              resume            (--global)
-  harbor login           re-authenticate   (--no-browser to paste a code,
-                         --workspace <id> to switch workspace, no browser needed)
-  harbor logout          forget this machine's credential
-
-Points at the hosted harbor.
-`;
-function output(json, jsonValue, text) {
-    process.stdout.write(json ? `${JSON.stringify(jsonValue, null, 2)}\n` : `${text}\n`);
-}
-export async function main(argv) {
-    const { verb, flags } = parseArgs(argv);
-    const json = flags.json === true;
-    const cwd = typeof flags.cwd === 'string' ? flags.cwd : process.cwd();
-    const endpoints = resolveEndpoints();
-    switch (verb) {
-        case 'version': {
-            const { readFile } = await import('node:fs/promises');
-            const { fileURLToPath } = await import('node:url');
-            const { dirname, join } = await import('node:path');
-            const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
-            const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
-            output(json, { version: pkg.version }, pkg.version);
-            return 0;
-        }
-        case 'help': {
-            process.stdout.write(USAGE);
-            if (typeof flags.unknownVerb === 'string') {
-                process.stderr.write(`\nUnknown command: ${flags.unknownVerb}\n`);
-                return 2;
-            }
-            return 0;
-        }
-        case 'init': {
-            const result = await runInit({
-                cwd,
-                endpoints,
-                noBrowser: flags['no-browser'] === true,
-                workspaceId: typeof flags.workspace === 'string' ? flags.workspace : undefined,
-                bind: flags['no-bind'] === true ? false : undefined,
-                codex: flags['no-codex'] === true ? false : flags.codex === true ? true : undefined,
-                cursor: flags['no-cursor'] === true ? false : flags.cursor === true ? true : undefined,
-                daemon: flags['no-daemon'] === true ? false : undefined,
-            });
-            const { envShadowWarning: initShadow } = await import('./auth/store.js');
-            const initWarning = initShadow();
-            if (initWarning)
-                process.stderr.write(`${initWarning}\n`);
-            output(json, result, renderInit(result));
-            return 0;
-        }
-        case 'login': {
-            const { login } = await import('./auth/login.js');
-            const { envShadowWarning } = await import('./auth/store.js');
-            const { auth, reused } = await login(endpoints, {
-                noBrowser: flags['no-browser'] === true,
-                workspaceId: typeof flags.workspace === 'string' ? flags.workspace : undefined,
-            });
-            const shadow = envShadowWarning();
-            if (shadow)
-                process.stderr.write(`${shadow}\n`);
-            output(json, { workspace: auth.workspaceName, reused }, reused
-                ? `Already signed in to "${auth.workspaceName}".`
-                : `Signed in to "${auth.workspaceName}".`);
-            return 0;
-        }
-        case 'logout': {
-            await runLogout();
-            output(json, { ok: true }, 'Credential removed. Hooks and config left in place.');
-            return 0;
-        }
-        case 'bind': {
-            const result = await runBind({
-                cwd,
-                endpoints,
-                project: typeof flags.project === 'string' ? flags.project : undefined,
-            });
-            output(json, result, renderBind(result));
-            return 0;
-        }
-        case 'unbind': {
-            const result = await runUnbind({ cwd });
-            output(json, result, renderUnbind(result));
-            return 0;
-        }
-        case 'sync': {
-            const result = await runSync({ cwd, endpoints });
-            output(json, result, renderSync(result));
-            return exitCodeForSync(result);
-        }
-        case 'daemon': {
-            const result = await runDaemon({
-                endpoints,
-                once: flags.once === true,
-                install: flags.install === true,
-                uninstall: flags.uninstall === true,
-                status: flags.status === true,
-            });
-            if (json && result.mode !== 'ran')
-                output(true, result, '');
-            else
-                process.stdout.write(`${renderDaemon(result)}\n`);
-            return exitCodeForDaemon(result);
-        }
-        case 'status': {
-            const checks = await runStatus({ cwd });
-            output(json, checksToJson(checks), renderChecks(checks));
-            return exitCodeFor(checks);
-        }
-        case 'workspaces': {
-            const result = await runWorkspaces({ endpoints });
-            output(json, result, renderWorkspaces(result));
-            return 0;
-        }
-        case 'doctor': {
-            const report = await runDoctor({
-                cwd,
-                endpoints,
-                offline: flags.offline === true,
-                windowDays: typeof flags.days === 'string' ? Number.parseInt(flags.days, 10) : undefined,
-            });
-            output(json, { checks: checksToJson(report.checks), metrics: report.metrics }, renderChecks(report.checks));
-            return exitCodeFor(report.checks);
-        }
-        case 'context': {
-            const result = await runContext({ cwd, verbose: flags.verbose === true });
-            output(json, contextToJson(result), renderContext(result));
-            return 0;
-        }
-        case 'off': {
-            const result = await runOff({
-                cwd,
-                captureOnly: flags.capture === true,
-                receiptOnly: flags.receipt === true,
-                global: flags.global === true,
-            });
-            output(json, result, renderToggle(result));
-            return 0;
-        }
-        case 'on': {
-            const result = await runOn({
-                cwd,
-                receiptOnly: flags.receipt === true,
-                global: flags.global === true,
-            });
-            output(json, result, renderToggle(result));
-            return 0;
-        }
-    }
-}
-function reportError(err, debug) {
-    if (debug) {
-        process.stderr.write(`${err.stack ?? String(err)}\n`);
-        return;
-    }
-    if (err instanceof NotSignedInError ||
-        err instanceof NoWorkspaceChosenError ||
-        err instanceof NotARepoError) {
-        process.stderr.write(`${err.message}\n`);
-        return;
-    }
-    process.stderr.write(`${err.message ?? String(err)}\n`);
-}
-export function isProgramEntry(argv1, moduleUrl, resolve = realpathSync) {
-    if (argv1 === undefined)
-        return false;
-    try {
-        return resolve(argv1) === resolve(fileURLToPath(moduleUrl));
-    }
-    catch {
-        return false;
-    }
-}
-if (isProgramEntry(process.argv[1], import.meta.url)) {
-    main(process.argv.slice(2))
-        .then((code) => {
-        process.exitCode = code;
-    })
-        .catch((err) => {
-        reportError(err, process.argv.includes('--debug'));
-        process.exitCode = 1;
-    });
-}

package/dist/install-hooks.d.ts

@@ -1,11 +0,0 @@
-import { type HookPaths } from './providers/claude.js';
-export declare const HOOK_FILES: readonly string[];
-export declare function packagedHooksDir(): string;
-export declare function hookPathsIn(dir: string): HookPaths;
-export interface HookInstallResult {
-    readonly dir: string;
-    readonly files: readonly string[];
-    readonly paths: HookPaths;
-}
-export declare function installHookScripts(sourceDir?: string): Promise<HookInstallResult>;
-export declare function hookScriptsAreCurrent(sourceDir?: string): Promise<boolean>;

package/dist/install-hooks.js

@@ -1,64 +0,0 @@
-import { chmod, copyFile, mkdir, readFile, readdir, rename } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { hooksBinDir } from './paths.js';
-import { HOOK_CAPTURE_BASENAME, HOOK_COMPACT_BASENAME, HOOK_CONTEXT_BASENAME, HOOK_REPORT_BASENAME, HOOK_TOOLCONTEXT_BASENAME, } from './providers/claude.js';
-export const HOOK_FILES = [
-    '_shared.mjs',
-    '_recall.mjs',
-    '_receipt.mjs',
-    '_upgrade.mjs',
-    HOOK_CONTEXT_BASENAME,
-    HOOK_REPORT_BASENAME,
-    HOOK_CAPTURE_BASENAME,
-    HOOK_TOOLCONTEXT_BASENAME,
-    HOOK_COMPACT_BASENAME,
-];
-export function packagedHooksDir() {
-    return join(dirname(fileURLToPath(import.meta.url)), '..', 'hooks');
-}
-export function hookPathsIn(dir) {
-    return {
-        contextHookPath: join(dir, HOOK_CONTEXT_BASENAME),
-        reportHookPath: join(dir, HOOK_REPORT_BASENAME),
-        captureHookPath: join(dir, HOOK_CAPTURE_BASENAME),
-        toolContextHookPath: join(dir, HOOK_TOOLCONTEXT_BASENAME),
-        compactHookPath: join(dir, HOOK_COMPACT_BASENAME),
-    };
-}
-export async function installHookScripts(sourceDir = packagedHooksDir()) {
-    const dir = hooksBinDir();
-    await mkdir(dir, { recursive: true, mode: 0o700 });
-    const available = new Set(await readdir(sourceDir));
-    const missing = HOOK_FILES.filter((f) => !available.has(f));
-    if (missing.length > 0) {
-        throw new Error(`Hook scripts missing from ${sourceDir}: ${missing.join(', ')}. ` +
-            `This is a packaging fault, not a configuration one.`);
-    }
-    for (const file of HOOK_FILES) {
-        const target = join(dir, file);
-        const tmp = `${target}.${process.pid}.tmp`;
-        await copyFile(join(sourceDir, file), tmp);
-        const executable = !file.startsWith('_');
-        await chmod(tmp, executable ? 0o700 : 0o600);
-        await rename(tmp, target);
-    }
-    return { dir, files: HOOK_FILES, paths: hookPathsIn(dir) };
-}
-export async function hookScriptsAreCurrent(sourceDir = packagedHooksDir()) {
-    const dir = hooksBinDir();
-    for (const file of HOOK_FILES) {
-        try {
-            const [installed, shipped] = await Promise.all([
-                readFile(join(dir, file), 'utf8'),
-                readFile(join(sourceDir, file), 'utf8'),
-            ]);
-            if (installed !== shipped)
-                return false;
-        }
-        catch {
-            return false;
-        }
-    }
-    return true;
-}

package/dist/lock.d.ts

@@ -1,31 +0,0 @@
-export declare const LOCK_STALE_MS = 10000;
-export declare const LOCK_WAIT_MS = 15000;
-export declare class LockTimeoutError extends Error {
-    readonly lockPath: string;
-    constructor(lockPath: string);
-}
-export declare function lockPathFor(targetPath: string): string;
-export declare function readLockHolder(targetPath: string): Promise<{
-    readonly pid: number;
-    readonly host: string;
-    readonly at: string;
-} | null>;
-export interface LockHandle {
-    stillHeld(): Promise<boolean>;
-}
-export interface FileLockOptions {
-    readonly waitMs?: number;
-    readonly staleMs?: number;
-    readonly renewMs?: number;
-}
-export declare function withFileLock<T>(targetPath: string, critical: (lock: LockHandle) => Promise<T>, opts?: FileLockOptions): Promise<T>;
-export declare function writeFileAtomic(path: string, contents: string, options?: {
-    readonly mode?: number | 'preserve';
-}): Promise<void>;
-export declare function ensureConfigDir(dir: string): Promise<void>;
-export declare function readIfExists(path: string): Promise<string>;
-export declare class LockLostError extends Error {
-    readonly path: string;
-    constructor(path: string);
-}
-export declare function updateFileLocked(path: string, transform: (existing: string) => string | Promise<string>): Promise<void>;

package/dist/lock.js

@@ -1,192 +0,0 @@
-import { constants as fsConstants } from 'node:fs';
-import { chmod, mkdir, open, readFile, realpath, rename, rm, stat, utimes, writeFile, } from 'node:fs/promises';
-import { hostname } from 'node:os';
-import { createHash, randomUUID } from 'node:crypto';
-import { dirname, join } from 'node:path';
-import { locksDir } from './paths.js';
-export const LOCK_STALE_MS = 10_000;
-export const LOCK_WAIT_MS = 15_000;
-const POLL_MIN_MS = 5;
-const POLL_MAX_MS = 100;
-export class LockTimeoutError extends Error {
-    lockPath;
-    constructor(lockPath) {
-        super(`Timed out waiting for ${lockPath}. Another harbor process ` +
-            `is holding it; retry in a moment.`);
-        this.lockPath = lockPath;
-        this.name = 'LockTimeoutError';
-    }
-}
-export function lockPathFor(targetPath) {
-    const digest = createHash('sha256').update(targetPath).digest('hex').slice(0, 16);
-    return join(locksDir(), `${digest}.lock`);
-}
-async function tryAcquire(lockPath, target) {
-    const token = randomUUID();
-    try {
-        const handle = await open(lockPath, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY, 0o600);
-        const owner = {
-            pid: process.pid,
-            host: hostname(),
-            at: new Date().toISOString(),
-            target,
-            token,
-        };
-        try {
-            await handle.writeFile(JSON.stringify(owner), 'utf8');
-        }
-        finally {
-            await handle.close();
-        }
-        return token;
-    }
-    catch (err) {
-        if (err.code === 'EEXIST')
-            return null;
-        throw err;
-    }
-}
-export async function readLockHolder(targetPath) {
-    try {
-        const raw = JSON.parse(await readFile(lockPathFor(targetPath), 'utf8'));
-        if (typeof raw.pid !== 'number' || typeof raw.at !== 'string')
-            return null;
-        return { pid: raw.pid, host: typeof raw.host === 'string' ? raw.host : '', at: raw.at };
-    }
-    catch {
-        return null;
-    }
-}
-async function stillOurs(lockPath, token) {
-    try {
-        const owner = JSON.parse(await readFile(lockPath, 'utf8'));
-        return owner.token === token;
-    }
-    catch {
-        return false;
-    }
-}
-async function releaseIfOurs(lockPath, token) {
-    if (!(await stillOurs(lockPath, token)))
-        return;
-    await rm(lockPath, { force: true });
-}
-async function breakIfStale(lockPath, staleMs) {
-    try {
-        const info = await stat(lockPath);
-        if (Date.now() - info.mtimeMs < staleMs)
-            return false;
-        await rm(lockPath, { force: true });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function touchIfOurs(lockPath, token) {
-    try {
-        if (!(await stillOurs(lockPath, token)))
-            return;
-        const now = new Date();
-        await utimes(lockPath, now, now);
-    }
-    catch {
-    }
-}
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-export async function withFileLock(targetPath, critical, opts = {}) {
-    const lockPath = lockPathFor(targetPath);
-    const staleMs = opts.staleMs ?? LOCK_STALE_MS;
-    await mkdir(dirname(lockPath), { recursive: true, mode: 0o700 });
-    const deadline = Date.now() + (opts.waitMs ?? LOCK_WAIT_MS);
-    let delay = POLL_MIN_MS;
-    let token = null;
-    for (;;) {
-        token = await tryAcquire(lockPath, targetPath);
-        if (token !== null)
-            break;
-        if (await breakIfStale(lockPath, staleMs))
-            continue;
-        if (Date.now() >= deadline)
-            throw new LockTimeoutError(lockPath);
-        await sleep(delay);
-        delay = Math.min(delay * 2, POLL_MAX_MS);
-    }
-    const held = token;
-    const renew = opts.renewMs === undefined
-        ? null
-        : setInterval(() => void touchIfOurs(lockPath, held), opts.renewMs);
-    renew?.unref?.();
-    try {
-        return await critical({ stillHeld: () => stillOurs(lockPath, held) });
-    }
-    finally {
-        if (renew)
-            clearInterval(renew);
-        await releaseIfOurs(lockPath, held);
-    }
-}
-export async function writeFileAtomic(path, contents, options = {}) {
-    const requested = options.mode ?? 0o600;
-    const mode = requested === 'preserve'
-        ? await stat(path)
-            .then((s) => s.mode & 0o777)
-            .catch(() => null)
-        : requested;
-    const target = await realpath(path).catch(() => path);
-    const tmp = `${target}.${process.pid}.tmp`;
-    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-    await writeFile(tmp, contents, {
-        encoding: 'utf8',
-        ...(mode === null ? {} : { mode }),
-    });
-    await rename(tmp, target);
-}
-export async function ensureConfigDir(dir) {
-    await mkdir(dir, { recursive: true, mode: 0o700 });
-    if (process.platform === 'win32')
-        return;
-    try {
-        await chmod(dir, 0o700);
-    }
-    catch {
-    }
-}
-export async function readIfExists(path) {
-    try {
-        return await readFile(path, 'utf8');
-    }
-    catch (err) {
-        if (err.code === 'ENOENT')
-            return '';
-        throw err;
-    }
-}
-export class LockLostError extends Error {
-    path;
-    constructor(path) {
-        super(`Could not complete an exclusive update of ${path}: the lock was broken ` +
-            `mid-write on every attempt. Another harbor process is ` +
-            `contending for it, or this machine was suspended mid-update; retry.`);
-        this.path = path;
-        this.name = 'LockLostError';
-    }
-}
-const UPDATE_ATTEMPTS = 3;
-export async function updateFileLocked(path, transform) {
-    for (let attempt = 0; attempt < UPDATE_ATTEMPTS; attempt += 1) {
-        const lostTheLock = await withFileLock(path, async (lock) => {
-            const existing = await readIfExists(path);
-            const next = await transform(existing);
-            if (next === existing)
-                return false;
-            if (!(await lock.stillHeld()))
-                return true;
-            await writeFileAtomic(path, next);
-            return false;
-        });
-        if (!lostTheLock)
-            return;
-    }
-    throw new LockLostError(path);
-}

package/dist/machine.d.ts

@@ -1,13 +0,0 @@
-export interface MachineIdentity {
-    readonly id: string;
-    readonly createdAt: string;
-}
-export interface MachineFacts extends MachineIdentity {
-    readonly hostname: string;
-    readonly os: string;
-    readonly osVersion: string;
-    readonly cliVersion: string;
-}
-export declare function readMachineIdentity(): Promise<MachineIdentity>;
-export declare function readCliVersion(): Promise<string>;
-export declare function readMachineFacts(): Promise<MachineFacts>;

package/dist/machine.js

@@ -1,53 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { hostname, platform, release } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ensureConfigDir, updateFileLocked } from './lock.js';
-import { machineFile } from './paths.js';
-const isIdentity = (raw) => {
-    if (raw === null || typeof raw !== 'object')
-        return false;
-    const obj = raw;
-    return typeof obj['id'] === 'string' && obj['id'].length > 0;
-};
-export async function readMachineIdentity() {
-    let identity;
-    await ensureConfigDir(dirname(machineFile()));
-    await updateFileLocked(machineFile(), (existing) => {
-        if (existing.trim() !== '') {
-            try {
-                const parsed = JSON.parse(existing);
-                if (isIdentity(parsed)) {
-                    identity = parsed;
-                    return existing;
-                }
-            }
-            catch {
-            }
-        }
-        identity = { id: randomUUID(), createdAt: new Date().toISOString() };
-        return `${JSON.stringify(identity, null, 2)}\n`;
-    });
-    return identity;
-}
-export async function readCliVersion() {
-    try {
-        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
-        const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
-        return typeof pkg.version === 'string' ? pkg.version : 'unknown';
-    }
-    catch {
-        return 'unknown';
-    }
-}
-export async function readMachineFacts() {
-    const identity = await readMachineIdentity();
-    return {
-        ...identity,
-        hostname: hostname(),
-        os: platform(),
-        osVersion: release(),
-        cliVersion: await readCliVersion(),
-    };
-}

package/dist/memories.d.ts

@@ -1,31 +0,0 @@
-export interface MemoryPayload {
-    readonly id: string;
-    readonly name: string;
-    readonly content: string;
-}
-export type MemoryResult = {
-    readonly id: string;
-    readonly file: string;
-    readonly status: 'synced';
-} | {
-    readonly file: string;
-    readonly status: 'removed';
-};
-export interface MemorySyncSummary {
-    readonly dir: string;
-    readonly results: readonly MemoryResult[];
-}
-export declare function encodeProjectPath(projectPath: string): string;
-export declare function syncMemoryFilesToHome(opts: {
-    readonly projectPath: string;
-    readonly memories: readonly MemoryPayload[];
-    readonly home?: string;
-}): Promise<MemorySyncSummary>;
-export declare function removeProjectMemoryFiles(opts: {
-    readonly projectPath: string;
-    readonly home?: string;
-}): Promise<{
-    readonly dir: string;
-    readonly results: readonly MemoryResult[];
-    readonly status: 'cleaned' | 'no_dir';
-}>;