harborloop 0.3.0 → 0.4.0-rc.0

package/dist/providers/codex-trust.d.ts

@@ -1,36 +0,0 @@
-export interface CodexHookMetadata {
-    readonly key: string;
-    readonly eventName: string;
-    readonly command: string | null;
-    readonly sourcePath: string;
-    readonly enabled: boolean;
-    readonly currentHash: string;
-    readonly trustStatus: 'managed' | 'untrusted' | 'trusted' | 'modified';
-}
-export interface CodexHooksListResult {
-    readonly hooks: readonly CodexHookMetadata[];
-    readonly warnings: readonly string[];
-}
-export interface CodexProbeHost {
-    readonly binary: string;
-    readonly env: NodeJS.ProcessEnv;
-    readonly client: {
-        readonly name: string;
-        readonly title: string;
-        readonly version: string;
-    };
-}
-export declare function listCodexHooks(opts: {
-    readonly cwd: string;
-    readonly home?: string;
-    readonly host?: CodexProbeHost;
-}): Promise<CodexHooksListResult>;
-export interface TrustResult {
-    readonly verified: number;
-    readonly skippedReason: string | null;
-}
-export declare function stampAndVerify(opts: {
-    readonly probeCwd: string;
-    readonly home?: string;
-    readonly host?: CodexProbeHost;
-}): Promise<TrustResult>;

package/dist/providers/codex-trust.js

@@ -1,141 +0,0 @@
-import { spawn } from 'node:child_process';
-import { isOurHookCommand, resolveCodexPaths } from './codex.js';
-const PROBE_TIMEOUT_MS = 15_000;
-const cliHost = () => ({
-    binary: 'codex',
-    env: process.env,
-    client: { name: 'harbor-cli', title: 'harbor', version: '1.0.0' },
-});
-const asString = (v) => (typeof v === 'string' ? v : '');
-function toHookMetadata(raw) {
-    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
-        return null;
-    const o = raw;
-    const key = asString(o.key);
-    if (key === '')
-        return null;
-    return {
-        key,
-        eventName: asString(o.eventName),
-        command: typeof o.command === 'string' ? o.command : null,
-        sourcePath: asString(o.sourcePath),
-        enabled: o.enabled === true,
-        currentHash: asString(o.currentHash),
-        trustStatus: asString(o.trustStatus),
-    };
-}
-export async function listCodexHooks(opts) {
-    const host = opts.host ?? cliHost();
-    const env = { ...host.env };
-    if (opts.home !== undefined) {
-        env.CODEX_HOME = resolveCodexPaths(opts.home).codexDir;
-    }
-    return await new Promise((resolve, reject) => {
-        const child = spawn(host.binary, ['app-server'], {
-            cwd: opts.cwd,
-            env,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            windowsHide: true,
-        });
-        let settled = false;
-        let buffer = '';
-        const finish = (fn) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            try {
-                child.kill();
-            }
-            catch {
-            }
-            fn();
-        };
-        const timer = setTimeout(() => finish(() => reject(new Error('codex app-server timed out listing hooks'))), PROBE_TIMEOUT_MS);
-        child.on('error', (err) => finish(() => reject(err.code === 'ENOENT'
-            ? new Error('no `codex` on PATH')
-            : err)));
-        child.on('exit', (code) => finish(() => reject(new Error(`codex app-server exited early (code ${code ?? 'null'})`))));
-        const send = (id, method, params) => {
-            child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
-        };
-        child.stdout.on('data', (chunk) => {
-            buffer += chunk.toString('utf8');
-            let newline = buffer.indexOf('\n');
-            while (newline >= 0) {
-                const line = buffer.slice(0, newline).trim();
-                buffer = buffer.slice(newline + 1);
-                newline = buffer.indexOf('\n');
-                if (line === '')
-                    continue;
-                let msg;
-                try {
-                    msg = JSON.parse(line);
-                }
-                catch {
-                    continue;
-                }
-                if (msg.id === 1) {
-                    child.stdin.write(`${JSON.stringify({ method: 'initialized', params: {} })}\n`);
-                    send(2, 'hooks/list', { cwds: [opts.cwd] });
-                    continue;
-                }
-                if (msg.id !== 2)
-                    continue;
-                if (msg.error !== undefined) {
-                    const detail = JSON.stringify(msg.error);
-                    finish(() => reject(new Error(`codex hooks/list failed: ${detail}`)));
-                    return;
-                }
-                const result = msg.result;
-                const entries = Array.isArray(result?.data) ? result?.data : [];
-                const hooks = [];
-                const warnings = [];
-                for (const entry of entries) {
-                    if (entry === null || typeof entry !== 'object')
-                        continue;
-                    const e = entry;
-                    for (const h of Array.isArray(e.hooks) ? e.hooks : []) {
-                        const parsed = toHookMetadata(h);
-                        if (parsed !== null)
-                            hooks.push(parsed);
-                    }
-                    for (const w of Array.isArray(e.warnings) ? e.warnings : []) {
-                        if (typeof w === 'string')
-                            warnings.push(w);
-                    }
-                }
-                finish(() => resolve({ hooks, warnings }));
-                return;
-            }
-        });
-        send(1, 'initialize', {
-            clientInfo: host.client,
-            capabilities: { experimentalApi: true },
-        });
-    });
-}
-export async function stampAndVerify(opts) {
-    const { stampHookTrust, resolveCodexPaths: paths } = await import('./codex.js');
-    try {
-        const listed = await listCodexHooks({
-            cwd: opts.probeCwd,
-            home: opts.home,
-            host: opts.host,
-        });
-        const ours = listed.hooks.filter((h) => isOurHookCommand(h.command));
-        const identities = ours.map((h) => ({ key: h.key, currentHash: h.currentHash }));
-        const stampPath = ours[0]?.sourcePath ?? paths(opts.home).hooksJsonPath;
-        await stampHookTrust({ identities, hooksJsonPath: stampPath, home: opts.home });
-        const after = await listCodexHooks({
-            cwd: opts.probeCwd,
-            home: opts.home,
-            host: opts.host,
-        });
-        const verified = after.hooks.filter((h) => isOurHookCommand(h.command) && h.enabled && h.trustStatus === 'trusted').length;
-        return { verified, skippedReason: null };
-    }
-    catch (err) {
-        return { verified: 0, skippedReason: err.message };
-    }
-}

package/dist/providers/codex.d.ts

@@ -1,46 +0,0 @@
-import { type HookPaths } from './claude.js';
-export declare const MANAGED_HOOK_EVENTS: readonly string[];
-export interface CodexPaths {
-    readonly codexDir: string;
-    readonly configTomlPath: string;
-    readonly hooksJsonPath: string;
-}
-export declare function resolveCodexPaths(home?: string): CodexPaths;
-export declare function tomlString(value: string): string;
-export declare function mergeMcpServer(existing: string, mcpUrl: string, token: string): string;
-export declare function removeMcpServer(existing: string): string;
-export declare function hasMcpServer(existing: string): boolean;
-export declare function readInstalledToken(existing: string): string | null;
-export declare function readInstalledMcpUrl(existing: string): string | null;
-export interface CodexHookIdentity {
-    readonly key: string;
-    readonly currentHash: string;
-}
-export declare function mergeHookTrust(existing: string, hooksJsonPath: string, identities: readonly CodexHookIdentity[]): string;
-export declare function removeHookTrust(existing: string, hooksJsonPath: string): string;
-export declare function countHookTrustStamps(existing: string, hooksJsonPath: string): number;
-export declare function isOurHookCommand(command: unknown): boolean;
-export declare function mergeHooks(existing: string, paths: HookPaths): string;
-export declare function removeHooks(existing: string): string;
-export interface InstalledHooks {
-    readonly installed: boolean;
-    readonly commands: readonly string[];
-    readonly events: readonly string[];
-}
-export declare function readInstalledHooks(existing: string): InstalledHooks;
-export declare function hasHooks(existing: string): boolean;
-export declare function readCodexConfig(home?: string): Promise<string>;
-export declare function readCodexHooksJson(home?: string): Promise<string>;
-export declare function installMcpServer(opts: {
-    readonly mcpUrl: string;
-    readonly token: string;
-    readonly home?: string;
-}): Promise<string>;
-export declare function uninstallMcpServer(home?: string): Promise<string>;
-export declare function installHooks(paths: HookPaths, home?: string): Promise<string>;
-export declare function uninstallHooks(home?: string): Promise<string>;
-export declare function stampHookTrust(opts: {
-    readonly identities: readonly CodexHookIdentity[];
-    readonly hooksJsonPath?: string;
-    readonly home?: string;
-}): Promise<void>;