harborloop 0.3.0 → 0.4.1

package/dist/auth/pkce.js

@@ -1,14 +0,0 @@
-import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
-export function createPkcePair() {
-    const verifier = randomBytes(32).toString('base64url');
-    const challenge = createHash('sha256').update(verifier).digest('base64url');
-    return { verifier, challenge };
-}
-export function createState() {
-    return randomBytes(16).toString('base64url');
-}
-export function statesMatch(expected, received) {
-    const a = Buffer.from(expected);
-    const b = Buffer.from(received);
-    return a.length === b.length && timingSafeEqual(a, b);
-}

package/dist/auth/store.d.ts

@@ -1,26 +0,0 @@
-export interface StoredAuth {
-    readonly runnerToken: string;
-    readonly workspaceId: string;
-    readonly workspaceName: string;
-    readonly apiUrl: string;
-    readonly signedInAt: string;
-    readonly mcpMintedAt?: string;
-    readonly mcpConnectionId?: string;
-}
-export declare function readAuth(): Promise<StoredAuth | null>;
-export declare function isPendingWorkspace(auth: StoredAuth): boolean;
-export interface Credentials {
-    readonly runnerToken: string;
-    readonly workspaceId: string;
-    readonly source: 'env' | 'file';
-}
-export declare class PartialEnvCredentialError extends Error {
-    constructor(missing: string);
-}
-export declare function resolveCredentials(env?: NodeJS.ProcessEnv): Promise<Credentials | null>;
-export declare function envShadowWarning(env?: NodeJS.ProcessEnv): string | null;
-export declare function writeAuth(auth: StoredAuth): Promise<void>;
-export declare function clearAuth(): Promise<void>;
-export declare function decodeJwtClaims(token: string): Record<string, unknown> | null;
-export declare function jwtExpiry(token: string): Date | null;
-export declare function isExpired(token: string, now?: Date): boolean;

package/dist/auth/store.js

@@ -1,107 +0,0 @@
-import { chmod, readFile } from 'node:fs/promises';
-import { updateFileLocked } from '../lock.js';
-import { authFile } from '../paths.js';
-function parse(raw) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (parsed === null || typeof parsed !== 'object')
-        return null;
-    const obj = parsed;
-    if (typeof obj.runnerToken !== 'string' ||
-        typeof obj.workspaceId !== 'string' ||
-        typeof obj.apiUrl !== 'string') {
-        return null;
-    }
-    return {
-        runnerToken: obj.runnerToken,
-        workspaceId: obj.workspaceId,
-        workspaceName: typeof obj.workspaceName === 'string' ? obj.workspaceName : obj.workspaceId,
-        apiUrl: obj.apiUrl,
-        signedInAt: typeof obj.signedInAt === 'string' ? obj.signedInAt : '',
-        mcpMintedAt: typeof obj.mcpMintedAt === 'string' ? obj.mcpMintedAt : undefined,
-        mcpConnectionId: typeof obj.mcpConnectionId === 'string' ? obj.mcpConnectionId : undefined,
-    };
-}
-export async function readAuth() {
-    try {
-        return parse(await readFile(authFile(), 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-export function isPendingWorkspace(auth) {
-    return auth.workspaceId === '';
-}
-export class PartialEnvCredentialError extends Error {
-    constructor(missing) {
-        super(`${missing} is not set. HARBOR_TOKEN and HARBOR_WORKSPACE_ID must be set together — ` +
-            'a token without a workspace would silently sync whichever workspace this machine last signed in to.');
-        this.name = 'PartialEnvCredentialError';
-    }
-}
-export async function resolveCredentials(env = process.env) {
-    const token = (env['HARBOR_TOKEN'] ?? env['ALEF0_TOKEN'])?.trim();
-    const workspaceId = (env['HARBOR_WORKSPACE_ID'] ?? env['ALEF0_WORKSPACE_ID'])?.trim();
-    if (token || workspaceId) {
-        if (!token)
-            throw new PartialEnvCredentialError('HARBOR_TOKEN');
-        if (!workspaceId)
-            throw new PartialEnvCredentialError('HARBOR_WORKSPACE_ID');
-        return { runnerToken: token, workspaceId, source: 'env' };
-    }
-    const stored = await readAuth();
-    if (!stored || isPendingWorkspace(stored))
-        return null;
-    return {
-        runnerToken: stored.runnerToken,
-        workspaceId: stored.workspaceId,
-        source: 'file',
-    };
-}
-export function envShadowWarning(env = process.env) {
-    const name = env['HARBOR_TOKEN']?.trim()
-        ? 'HARBOR_TOKEN'
-        : env['ALEF0_TOKEN']?.trim()
-            ? 'ALEF0_TOKEN'
-            : null;
-    if (!name)
-        return null;
-    return (`⚠ ${name} is set in this environment, and it wins over the credential just saved. ` +
-        `\`harbor sync\` and the daemon will keep using it until you unset it.`);
-}
-export async function writeAuth(auth) {
-    await updateFileLocked(authFile(), () => `${JSON.stringify(auth, null, 2)}\n`);
-    await chmod(authFile(), 0o600).catch(() => undefined);
-}
-export async function clearAuth() {
-    await updateFileLocked(authFile(), () => '');
-}
-export function decodeJwtClaims(token) {
-    const parts = token.split('.');
-    if (parts.length !== 3)
-        return null;
-    try {
-        const json = Buffer.from(parts[1], 'base64url').toString('utf8');
-        const claims = JSON.parse(json);
-        return claims !== null && typeof claims === 'object'
-            ? claims
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function jwtExpiry(token) {
-    const exp = decodeJwtClaims(token)?.exp;
-    return typeof exp === 'number' ? new Date(exp * 1000) : null;
-}
-export function isExpired(token, now = new Date()) {
-    const expiry = jwtExpiry(token);
-    return expiry !== null && expiry.getTime() <= now.getTime();
-}

package/dist/cli-release.d.ts

@@ -1,31 +0,0 @@
-export declare const RELEASE_TTL_MS: number;
-export declare const UPGRADE_COMMAND = "npx harborloop@latest init";
-export interface CliRelease {
-    readonly latest: string;
-    readonly current: string;
-    readonly behind: boolean;
-    readonly command: string;
-    readonly checkedAt: string;
-}
-export declare function compareVersions(a: string, b: string): number;
-export declare function fetchLatestVersion(fetchImpl?: typeof fetch): Promise<string | null>;
-export declare function readCliRelease(): Promise<CliRelease | null>;
-export type ReleaseCheck = {
-    readonly kind: 'checked';
-    readonly release: CliRelease;
-} | {
-    readonly kind: 'cached';
-    readonly release: CliRelease;
-} | {
-    readonly kind: 'unreachable';
-} | {
-    readonly kind: 'unknown-version';
-};
-export interface RefreshOptions {
-    readonly now?: Date;
-    readonly ttlMs?: number;
-    readonly fetchImpl?: typeof fetch;
-    readonly force?: boolean;
-}
-export declare function refreshCliRelease(opts?: RefreshOptions): Promise<ReleaseCheck>;
-export declare function describeRelease(check: ReleaseCheck): string | null;

package/dist/cli-release.js

@@ -1,102 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { apiRequest } from './api.js';
-import { ensureConfigDir, writeFileAtomic } from './lock.js';
-import { readCliVersion } from './machine.js';
-import { cliReleaseFile, harborDir } from './paths.js';
-const NPM_LATEST_URL = 'https://registry.npmjs.org/harborloop/latest';
-export const RELEASE_TTL_MS = 6 * 60 * 60 * 1000;
-const FETCH_TIMEOUT_MS = 5_000;
-export const UPGRADE_COMMAND = 'npx harborloop@latest init';
-export function compareVersions(a, b) {
-    const [coreA = '', preA = ''] = a.trim().split('-', 2);
-    const [coreB = '', preB = ''] = b.trim().split('-', 2);
-    const partsA = coreA.split('.');
-    const partsB = coreB.split('.');
-    const width = Math.max(partsA.length, partsB.length);
-    for (let i = 0; i < width; i += 1) {
-        const numA = Number.parseInt(partsA[i] ?? '0', 10);
-        const numB = Number.parseInt(partsB[i] ?? '0', 10);
-        const left = Number.isFinite(numA) ? numA : 0;
-        const right = Number.isFinite(numB) ? numB : 0;
-        if (left !== right)
-            return left - right;
-    }
-    if (preA === preB)
-        return 0;
-    if (preA === '')
-        return 1;
-    if (preB === '')
-        return -1;
-    return preA < preB ? -1 : 1;
-}
-export async function fetchLatestVersion(fetchImpl) {
-    try {
-        const body = await apiRequest(NPM_LATEST_URL, {
-            timeoutMs: FETCH_TIMEOUT_MS,
-            ...(fetchImpl ? { fetchImpl } : {}),
-        });
-        const version = body?.version;
-        return typeof version === 'string' && version.trim() !== '' ? version.trim() : null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function readCliRelease() {
-    let raw;
-    try {
-        raw = await readFile(cliReleaseFile(), 'utf8');
-    }
-    catch {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.latest !== 'string' || typeof parsed.current !== 'string')
-            return null;
-        return {
-            latest: parsed.latest,
-            current: parsed.current,
-            behind: parsed.behind === true,
-            command: typeof parsed.command === 'string' ? parsed.command : UPGRADE_COMMAND,
-            checkedAt: typeof parsed.checkedAt === 'string' ? parsed.checkedAt : '',
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function refreshCliRelease(opts = {}) {
-    const now = opts.now ?? new Date();
-    const ttlMs = opts.ttlMs ?? RELEASE_TTL_MS;
-    const stored = await readCliRelease();
-    if (!opts.force && stored && stored.checkedAt !== '') {
-        const age = now.getTime() - Date.parse(stored.checkedAt);
-        if (Number.isFinite(age) && age < ttlMs)
-            return { kind: 'cached', release: stored };
-    }
-    const current = await readCliVersion();
-    if (current === 'unknown')
-        return { kind: 'unknown-version' };
-    const latest = await fetchLatestVersion(opts.fetchImpl);
-    if (latest === null)
-        return { kind: 'unreachable' };
-    const release = {
-        latest,
-        current,
-        behind: compareVersions(current, latest) < 0,
-        command: UPGRADE_COMMAND,
-        checkedAt: now.toISOString(),
-    };
-    await ensureConfigDir(harborDir());
-    await writeFileAtomic(cliReleaseFile(), `${JSON.stringify(release, null, 2)}\n`);
-    return { kind: 'checked', release };
-}
-export function describeRelease(check) {
-    if (check.kind === 'unreachable' || check.kind === 'unknown-version')
-        return null;
-    const { release } = check;
-    return release.behind
-        ? `${release.latest} available (this machine runs ${release.current})`
-        : null;
-}

package/dist/commands/bind.d.ts

@@ -1,23 +0,0 @@
-import type { Endpoints } from '../endpoints.js';
-export declare class NotSignedInError extends Error {
-    constructor();
-}
-export declare class NoWorkspaceChosenError extends Error {
-    constructor();
-}
-export declare class NotARepoError extends Error {
-    constructor(cwd: string);
-}
-export interface BindOptions {
-    readonly cwd: string;
-    readonly endpoints: Endpoints;
-    readonly project?: string;
-}
-export interface BindResult {
-    readonly originUrl: string;
-    readonly projectName: string | null;
-    readonly alreadyBound: boolean;
-    readonly originCount: number;
-}
-export declare function runBind(opts: BindOptions): Promise<BindResult>;
-export declare function renderBind(result: BindResult): string;

package/dist/commands/bind.js

@@ -1,86 +0,0 @@
-import { createRepoBinding, listProjects, listRepoBindings, } from '../api.js';
-import { isPendingWorkspace, readAuth } from '../auth/store.js';
-import { installProjectOrigin } from '../providers/claude.js';
-import { gitRoot, repoOrigin } from '../origin.js';
-import { noteCheckout } from '../repos.js';
-import { updateSyncedConfig } from '../state.js';
-export class NotSignedInError extends Error {
-    constructor() {
-        super('Not signed in. Run `harbor init` first.');
-        this.name = 'NotSignedInError';
-    }
-}
-export class NoWorkspaceChosenError extends Error {
-    constructor() {
-        super('Signed in, but this machine has no workspace yet. Run `harbor login` to ' +
-            'finish choosing one — it will not need the browser again.');
-        this.name = 'NoWorkspaceChosenError';
-    }
-}
-export class NotARepoError extends Error {
-    constructor(cwd) {
-        super(`${cwd} has no git remote named "origin", so there is nothing to bind.`);
-        this.name = 'NotARepoError';
-    }
-}
-export async function runBind(opts) {
-    const auth = await readAuth();
-    if (!auth)
-        throw new NotSignedInError();
-    if (isPendingWorkspace(auth))
-        throw new NoWorkspaceChosenError();
-    const origin = repoOrigin(opts.cwd);
-    if (origin === '')
-        throw new NotARepoError(opts.cwd);
-    const existing = await listRepoBindings(opts.endpoints.apiUrl, auth.runnerToken, auth.workspaceId);
-    const already = existing.find((b) => b.originUrl === origin) ?? null;
-    let projectId;
-    let projectName = already?.projectName ?? null;
-    if (opts.project) {
-        const projects = await listProjects(opts.endpoints.apiUrl, auth.runnerToken, auth.workspaceId);
-        const match = projects.find((p) => p.id === opts.project) ??
-            projects.find((p) => p.name.toLowerCase() === opts.project.toLowerCase());
-        if (!match) {
-            throw new Error(`No project named "${opts.project}". Available: ${projects.map((p) => p.name).join(', ') || '(none)'}`);
-        }
-        projectId = match.id;
-        projectName = match.name;
-    }
-    let binding = already;
-    if (!already) {
-        binding = await createRepoBinding(opts.endpoints.apiUrl, auth.runnerToken, auth.workspaceId, { originUrl: origin, ...(projectId ? { projectId } : {}) });
-        projectName = binding.projectName ?? projectName;
-    }
-    const refreshed = await listRepoBindings(opts.endpoints.apiUrl, auth.runnerToken, auth.workspaceId);
-    const config = await updateSyncedConfig((current) => ({
-        ...current,
-        apiBase: opts.endpoints.apiUrl,
-        origins: refreshed.map((b) => b.originUrl),
-    }));
-    const root = gitRoot(opts.cwd);
-    if (root !== null)
-        await noteCheckout(origin, root);
-    if (root !== null) {
-        try {
-            await installProjectOrigin({ repoPath: root, originUrl: origin });
-        }
-        catch {
-        }
-    }
-    return {
-        originUrl: origin,
-        projectName,
-        alreadyBound: already !== null,
-        originCount: config.origins.length,
-    };
-}
-export function renderBind(result) {
-    const scope = result.projectName
-        ? `project "${result.projectName}"`
-        : 'the workspace (no project)';
-    const verb = result.alreadyBound ? 'Already bound' : 'Bound';
-    return [
-        `${verb}: ${result.originUrl} → ${scope}`,
-        `${result.originCount} repo${result.originCount === 1 ? '' : 's'} in the local allowlist.`,
-    ].join('\n');
-}

package/dist/commands/context.d.ts

@@ -1,12 +0,0 @@
-import { type ContextBudget } from '../context-budget.js';
-export interface ContextOptions {
-    readonly cwd: string;
-    readonly verbose?: boolean;
-}
-export interface ContextResult extends ContextBudget {
-    readonly repoPath: string | null;
-    readonly verbose: boolean;
-}
-export declare function runContext(opts: ContextOptions): Promise<ContextResult>;
-export declare function renderContext(result: ContextResult): string;
-export declare function contextToJson(result: ContextResult): unknown;

package/dist/commands/context.js

@@ -1,80 +0,0 @@
-import { gitRoot } from '../origin.js';
-import { measureContext, } from '../context-budget.js';
-export async function runContext(opts) {
-    const repoPath = gitRoot(opts.cwd);
-    const budget = await measureContext({ repoPath });
-    return { ...budget, repoPath, verbose: opts.verbose === true };
-}
-function figure(tokens) {
-    return tokens.toLocaleString('en-US');
-}
-const OWNER_LABEL = {
-    harbor: 'harbor',
-    'other-tool': 'other tool',
-    nobody: 'unowned',
-};
-function renderLine(line, width) {
-    const count = line.count === null ? '' : ` (${line.count})`;
-    const label = `${line.label}${count}`.padEnd(width);
-    const cost = line.tokens === null ? '—'.padStart(9) : `~${figure(line.tokens)}`.padStart(9);
-    const tail = line.unmeasured ?? line.note ?? '';
-    return `    ${label} ${cost}${tail ? `   ${tail}` : ''}`;
-}
-export function renderContext(result) {
-    const width = Math.max(...result.lines.map((line) => `${line.label}${line.count === null ? '' : ` (${line.count})`}`.length));
-    const out = [];
-    const header = result.unmeasuredLines > 0
-        ? `at least ~${figure(result.measuredTokens)} tok / turn`
-        : `~${figure(result.measuredTokens)} tok / turn`;
-    out.push(`  always-on budget on this machine   ${header}`);
-    for (const line of result.lines)
-        out.push(renderLine(line, width));
-    const { harbor, nobody } = result.ownership;
-    const other = result.ownership['other-tool'];
-    const indexed = result.skills.length - result.undiscoverable;
-    out.push('');
-    out.push(`  managed by harbor: ${harbor} of ${indexed} · unowned: ${nobody} · other tools: ${other}`);
-    if (result.undiscoverable > 0) {
-        out.push(`  ${result.undiscoverable} more file${result.undiscoverable === 1 ? '' : 's'} in a skills root carry no description — write one, or they are shelf-ware`);
-    }
-    if (result.repoPath === null) {
-        out.push('  (home only — run this inside a repository to price its lane too)');
-    }
-    if (result.verbose && result.skills.length > 0) {
-        out.push('');
-        const nameWidth = Math.max(...result.skills.map((s) => s.name.length));
-        for (const skill of sortedSkills(result.skills)) {
-            const copies = skill.copies > 1 ? `   ×${skill.copies} roots` : '';
-            out.push(`    ${skill.name.padEnd(nameWidth)} ${`~${figure(skill.tokens)}`.padStart(7)}   ${OWNER_LABEL[skill.owner]}${skill.undiscoverable ? '   no description' : ''}${copies}`);
-        }
-    }
-    return out.join('\n');
-}
-function sortedSkills(skills) {
-    return [...skills].sort((a, b) => b.tokens - a.tokens || a.name.localeCompare(b.name));
-}
-export function contextToJson(result) {
-    return {
-        measuredTokens: result.measuredTokens,
-        unmeasuredLines: result.unmeasuredLines,
-        repoPath: result.repoPath,
-        ownership: result.ownership,
-        undiscoverable: result.undiscoverable,
-        lines: result.lines.map((line) => ({
-            id: line.id,
-            label: line.label,
-            count: line.count,
-            tokens: line.tokens,
-            ...(line.unmeasured ? { unmeasured: line.unmeasured } : {}),
-            ...(line.note ? { note: line.note } : {}),
-        })),
-        skills: result.skills.map((skill) => ({
-            name: skill.name,
-            owner: skill.owner,
-            tokens: skill.tokens,
-            undiscoverable: skill.undiscoverable,
-            copies: skill.copies,
-            path: skill.path,
-        })),
-    };
-}

package/dist/commands/daemon.d.ts

@@ -1,39 +0,0 @@
-import type { Endpoints } from '../endpoints.js';
-import { type InstallOutcome } from '../daemon/install.js';
-import { type DaemonVerdict } from '../daemon/state.js';
-import { type DaemonTickReport } from '../daemon/tick.js';
-export interface DaemonOptions {
-    readonly endpoints: Endpoints;
-    readonly once?: boolean;
-    readonly install?: boolean;
-    readonly uninstall?: boolean;
-    readonly status?: boolean;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly fetchImpl?: typeof fetch;
-    readonly home?: string;
-    readonly signal?: AbortSignal;
-}
-export type DaemonResult = {
-    readonly mode: 'once';
-    readonly report: DaemonTickReport;
-} | {
-    readonly mode: 'skipped';
-    readonly detail: string;
-} | {
-    readonly mode: 'status';
-    readonly verdict: DaemonVerdict;
-    readonly units: readonly string[];
-} | {
-    readonly mode: 'install';
-    readonly outcome: InstallOutcome;
-} | {
-    readonly mode: 'uninstall';
-    readonly outcome: InstallOutcome;
-} | {
-    readonly mode: 'ran';
-    readonly ticks: number;
-};
-export declare function runDaemon(opts: DaemonOptions): Promise<DaemonResult>;
-export declare function renderTick(report: DaemonTickReport): string;
-export declare function renderDaemon(result: DaemonResult): string;
-export declare function exitCodeForDaemon(result: DaemonResult): number;

package/dist/commands/daemon.js

@@ -1,140 +0,0 @@
-import { daemonProgram, installDaemon, installPlan, installedFiles, uninstallDaemon, } from '../daemon/install.js';
-import { runDaemonLoop, TICK_INTERVAL_MS } from '../daemon/loop.js';
-import { daemonVerdict, readDaemonHeartbeat, recordTick, } from '../daemon/state.js';
-import { runDaemonTick, summarise } from '../daemon/tick.js';
-import { harborDir } from '../paths.js';
-export async function runDaemon(opts) {
-    if (opts.status === true) {
-        const plan = installPlan({
-            program: safeProgram(),
-            harborHome: harborDir(),
-        });
-        return {
-            mode: 'status',
-            verdict: daemonVerdict(await readDaemonHeartbeat()),
-            units: await installedFiles(plan),
-        };
-    }
-    if (opts.install === true || opts.uninstall === true) {
-        const plan = installPlan({
-            program: daemonProgram(),
-            harborHome: harborDir(),
-        });
-        return opts.install === true
-            ? { mode: 'install', outcome: await installDaemon({ plan }) }
-            : { mode: 'uninstall', outcome: await uninstallDaemon({ plan }) };
-    }
-    if (opts.once === true) {
-        const outcome = await runDaemonTick({
-            endpoints: opts.endpoints,
-            reason: 'once',
-            ...(opts.env ? { env: opts.env } : {}),
-            ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
-            ...(opts.home === undefined ? {} : { home: opts.home }),
-        });
-        if (outcome.kind === 'contended') {
-            return { mode: 'skipped', detail: outcome.detail };
-        }
-        const report = outcome.report;
-        await recordTick(summarise(report), {
-            mode: 'once',
-            startedBy: 'cli',
-            startedAt: report.startedAt,
-            pid: process.pid,
-            intervalMs: TICK_INTERVAL_MS,
-        });
-        return { mode: 'once', report };
-    }
-    let ticks = 0;
-    await runDaemonLoop({
-        endpoints: opts.endpoints,
-        ...(opts.env ? { env: opts.env } : {}),
-        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-        ...(opts.signal ? { signal: opts.signal } : {}),
-        onTick: (report) => {
-            ticks += 1;
-            process.stdout.write(`${renderTick(report)}\n`);
-        },
-        onSkipped: (detail) => process.stdout.write(`· ${detail}\n`),
-    });
-    return { mode: 'ran', ticks };
-}
-function safeProgram() {
-    try {
-        return daemonProgram();
-    }
-    catch {
-        return { interpreter: process.execPath, script: '' };
-    }
-}
-const GLYPH = { ok: '✓', skipped: '·', failed: '✗' };
-export function renderTick(report) {
-    const lines = [
-        `${GLYPH[report.credential.kind]} credential  ${report.credential.detail}`,
-        `${GLYPH[report.env.kind]} your env    ${report.env.detail}`,
-    ];
-    for (const repo of report.repos) {
-        lines.push(`${GLYPH[repo.outcome.kind]} ${repo.path}  ${repo.outcome.detail}`);
-    }
-    lines.push(`${GLYPH[report.report.kind]} report      ${report.report.detail}`);
-    return lines.join('\n');
-}
-export function renderDaemon(result) {
-    switch (result.mode) {
-        case 'once':
-            return renderTick(result.report);
-        case 'skipped':
-            return `· ${result.detail}`;
-        case 'status': {
-            const glyph = result.verdict.kind === 'ok'
-                ? '✓'
-                : result.verdict.kind === 'degraded' || result.verdict.kind === 'idle'
-                    ? '⚠'
-                    : '✗';
-            const head = `${glyph} ${result.verdict.detail}`;
-            const lines = [head];
-            if ('fix' in result.verdict)
-                lines.push(`  ↳ ${result.verdict.fix}`);
-            lines.push(result.units.length === 0
-                ? '  Not scheduled. `harbor daemon --install` sets it up.'
-                : `  Scheduled by ${result.units.join(', ')}`);
-            return lines.join('\n');
-        }
-        case 'install':
-        case 'uninstall': {
-            const lines = [result.outcome.detail];
-            for (const file of result.outcome.files)
-                lines.push(`  ${file}`);
-            for (const argv of result.outcome.manual)
-                lines.push(`  ${argv.join(' ')}`);
-            return lines.join('\n');
-        }
-        case 'ran':
-            return `Stopped after ${result.ticks} tick${result.ticks === 1 ? '' : 's'}.`;
-    }
-}
-export function exitCodeForDaemon(result) {
-    if (result.mode === 'skipped')
-        return 0;
-    if (result.mode === 'once') {
-        const failed = result.report.credential.kind === 'failed' ||
-            result.report.env.kind === 'failed' ||
-            result.report.report.kind === 'failed' ||
-            result.report.repos.some((r) => r.outcome.kind === 'failed');
-        return failed ? 1 : 0;
-    }
-    if (result.mode === 'status') {
-        return result.verdict.kind === 'ok' ||
-            result.verdict.kind === 'degraded' ||
-            result.verdict.kind === 'idle'
-            ? 0
-            : 1;
-    }
-    if (result.mode === 'install' || result.mode === 'uninstall') {
-        return result.outcome.kind === 'partial' || result.outcome.kind === 'unsupported'
-            ? 1
-            : 0;
-    }
-    return 0;
-}