@b00dea/cockpit 0.0.0-bootstrap.0 → 0.1.0

package/dist/cli-guard.js

@@ -0,0 +1,71 @@
+import { EXIT_CODES } from './invocation.js';
+import { GUARD_INPUT_LIMITS } from './guards/invocation-parser.js';
+import { adaptGuardDecision, normalizeOpenCodeInput } from './guards/harness-adapter.js';
+import { isGuardSurfaceTarget } from './surfaces/harness-registry.js';
+import { renderJsonResponse } from './diagnostics.js';
+import { RefusalError, errorCause } from './environment/contract.js';
+import { runGuardEvaluationApplication } from './environment/application/guard.js';
+import { observeSetupCheckout } from './environment/setup-observation.js';
+import { GUARD_EXECUTABLE_SEARCH_PATH, resolveDockerExecutable, resolveGitExecutable } from './environment/executable.js';
+import { executeProbe } from './environment-exec/execute.js';
+import { loadCockpitConfig } from './config/load.js';
+// The guard runs before every agent tool call, so this module imports only what a guard decision needs;
+// the rest of the CLI loads only for the other commands.
+export async function runGuardCommand(commandArgs, io, env) {
+    let harness;
+    let response;
+    try {
+        if (commandArgs.length !== 2 || commandArgs[0] !== '--harness'
+            || !isGuardSurfaceTarget(commandArgs[1]))
+            throw new RefusalError('Invalid private guard arguments.');
+        harness = commandArgs[1];
+        if (!io.stdin)
+            throw new RefusalError('Guard input stream is missing.');
+        const chunks = [];
+        let bytes = 0;
+        for await (const chunk of io.stdin) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            bytes += buffer.length;
+            if (bytes > GUARD_INPUT_LIMITS.inputBytes)
+                throw new RefusalError('Guard input exceeds its byte bound.');
+            chunks.push(buffer);
+        }
+        const raw = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks, bytes));
+        const native = JSON.parse(raw);
+        const payload = harness === 'opencode' && native?.tool !== undefined
+            ? normalizeOpenCodeInput(native)
+            : { hook_event_name: native?.hook_event_name, tool_name: native?.tool_name,
+                tool_input: native?.tool_input, cwd: native?.cwd ?? process.cwd() };
+        const identityBytes = env.COCKPIT_GUARD_IDENTITY;
+        if (!identityBytes || Buffer.byteLength(identityBytes) > GUARD_INPUT_LIMITS.inputBytes)
+            throw new RefusalError('Installed guard identity is missing or oversized.');
+        const guardRoot = env.COCKPIT_GUARD_ROOT;
+        if (!guardRoot)
+            throw new RefusalError('Installed guard root is missing.');
+        const guardEnvironment = env;
+        response = await runGuardEvaluationApplication({ identity: JSON.parse(identityBytes), guardRoot, payload, harness, cwd: process.cwd(),
+            askIsDeny: guardEnvironment.COCKPIT_ASK_IS_DENY === '1',
+            ripgrepConfigActive: Object.hasOwn(guardEnvironment, 'RIPGREP_CONFIG_PATH') || guardEnvironment.COCKPIT_RIPGREP_CONFIG_ACTIVE === '1',
+            searchPath: guardEnvironment.PATH ?? '' }, {
+            loadConfig: loadCockpitConfig, observeCheckout: observeSetupCheckout,
+            resolveGit: () => resolveGitExecutable({ PATH: GUARD_EXECUTABLE_SEARCH_PATH }),
+            resolveDocker: () => resolveDockerExecutable({ PATH: GUARD_EXECUTABLE_SEARCH_PATH }),
+            execute: executeProbe,
+        });
+    }
+    catch (error) {
+        const reason = `Guard input, arguments or installed identity are unavailable or malformed: ${errorCause(error)}`;
+        response = { decision: { decision: 'unavailable', reason },
+            diagnostics: [{ severity: 'error', code: 'GUARD_INPUT_UNAVAILABLE', message: reason, target: 'guard' }] };
+    }
+    // Project once at the publication boundary; adapters only spell the closed decision.
+    const projected = JSON.parse(renderJsonResponse({ result: response.decision, diagnostics: response.diagnostics }, response.fixContext));
+    const decision = projected.result.decision === 'ask' && env.COCKPIT_ASK_IS_DENY === '1'
+        ? { ...projected.result, decision: 'deny' } : projected.result;
+    const output = adaptGuardDecision(harness, decision);
+    io.stdout.write(output.stdout);
+    io.stderr.write(output.stderr);
+    const status = output.exitCode;
+    return status === EXIT_CODES.success ? EXIT_CODES.success
+        : status === EXIT_CODES.cancelled ? EXIT_CODES.cancelled : EXIT_CODES.failure;
+}

package/dist/cli-main.d.ts

@@ -0,0 +1,139 @@
+import { type EvaluatorTool } from './schema.js';
+import { type ScaffoldBackingService } from './init/scaffold.js';
+import { type ReleaseMetadataTransport } from './freshness.js';
+import { type HandlerIdentifier, type WorkHandlerIdentifier } from './command-table.js';
+import type { FixContext } from './fix-catalogue.js';
+import { type Diagnostic } from './diagnostics.js';
+import { type UnattendedInit } from './init/command.js';
+import { type InitApplicationInput, type InitApplicationOutcome, type InitResult } from './environment/init-application.js';
+import { type RegistryResolveCommandInput } from './registry-resolve/command.js';
+import { type SetupCommandInput } from './setup/command.js';
+import { type DoctorCommandInput } from './environment/application/doctor.js';
+import { type PreflightCommandInput } from './environment/application/health.js';
+import { type DownCommandInput, type ResetCommandInput, type SleepCommandInput, type UpCommandInput } from './environment/application/lifecycle-context.js';
+import { type SiblingAddInput, type SiblingRemoveInput } from './environment/sibling-registration.js';
+import { type ToolChangeInput } from './environment/tool-registration.js';
+import { type SetupRefusalEvidence } from './environment/contract.js';
+import { type GeneratedEnvironmentCommandInput } from './generated-environment/command.js';
+import type { GeneratedStaleRemovalApproval, GeneratedStaleRemovalApprovalRequest } from './environment/generated-application/shared.js';
+import { type SurfaceSelftestDraftInput, type SurfaceSelftestExecutableCandidate, type SurfaceSelftestProbeSpecificationsCandidate } from './environment/selftest-application.js';
+import { loadOperatorPolicy } from './environment/operator-application.js';
+import type { WorkApplicationRequest } from './work-orders/application.js';
+export interface CliIo {
+    stdout: Pick<NodeJS.WriteStream, 'write'>;
+    stderr: Pick<NodeJS.WriteStream, 'write'>;
+    stdin?: NodeJS.ReadStream;
+    confirmInit?: (preview: InitResult) => Promise<string | undefined>;
+    answerInitQuestion?: (question: NonNullable<InitResult['question']>) => Promise<string | undefined>;
+    confirmReset?: (preview: CommandOutcome) => Promise<boolean>;
+    confirmWorkOrder?: (candidate: Readonly<{
+        digest: string;
+        prompt: string;
+    }>) => Promise<string | undefined>;
+    confirmSelftestExecutable?: (candidate: SurfaceSelftestExecutableCandidate) => Promise<string | undefined>;
+    confirmSelftestProbeSpecifications?: (candidate: SurfaceSelftestProbeSpecificationsCandidate) => Promise<string | undefined>;
+    confirmStaleRemoval?: (request: GeneratedStaleRemovalApprovalRequest) => Promise<string | undefined>;
+}
+export interface CliRuntime {
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly signal?: AbortSignal;
+    readonly createReleaseMetadataTransport?: () => ReleaseMetadataTransport;
+}
+export interface CommandOutcome {
+    artifact?: string | null;
+    destination?: string | null;
+    diagnostics: readonly Diagnostic[];
+    evidence?: SetupRefusalEvidence;
+    result: unknown;
+    status: number;
+    fixContext?: FixContext;
+}
+interface WorkCommandInput {
+    readonly configPath: string;
+    readonly request: WorkApplicationRequest;
+    readonly evaluator?: EvaluatorTool;
+}
+interface HandlerInputById extends Record<WorkHandlerIdentifier, WorkCommandInput> {
+    check: GeneratedEnvironmentCommandInput;
+    init: InitApplicationInput & Readonly<{
+        unattended?: UnattendedInit;
+    }>;
+    doctor: DoctorCommandInput;
+    down: DownCommandInput;
+    logs: Readonly<{
+        configPath: string;
+        service: string;
+        since: string;
+        tail: number;
+        follow: boolean;
+        json: boolean;
+    }>;
+    preflight: PreflightCommandInput;
+    'registry-resolve': RegistryResolveCommandInput;
+    reset: ResetCommandInput;
+    runtime: Readonly<{
+        configPath: string;
+        image: string;
+    }>;
+    sibling: Readonly<{
+        operation: 'add';
+        input: Omit<SiblingAddInput, 'env'>;
+    }> | Readonly<{
+        operation: 'remove';
+        input: Omit<SiblingRemoveInput, 'env'>;
+    }>;
+    tool: ToolChangeInput;
+    setup: SetupCommandInput;
+    selftest: Readonly<{
+        configPath: string;
+        probeSpecificationsPath: string;
+        env: Readonly<Record<string, string | undefined>>;
+        requestExecutableApproval?: (candidate: SurfaceSelftestExecutableCandidate) => Promise<string | undefined>;
+        requestProbeSpecificationsApproval?: (candidate: SurfaceSelftestProbeSpecificationsCandidate) => Promise<string | undefined>;
+    }> | SurfaceSelftestDraftInput;
+    session: Readonly<{
+        configPath: string;
+        argv: readonly [string, ...string[]];
+        sessionId: string;
+    }>;
+    sleep: SleepCommandInput;
+    sync: GeneratedEnvironmentCommandInput & Readonly<{
+        dryRun?: boolean;
+        adopt?: readonly string[];
+        authorizeStaleRemoval?: (request: GeneratedStaleRemovalApprovalRequest) => Promise<GeneratedStaleRemovalApproval | undefined>;
+    }>;
+    up: UpCommandInput;
+    upgrade: Readonly<{
+        configPath: string;
+        version?: string;
+        dryRun: boolean;
+    }>;
+}
+export type CommandHandlers = {
+    [Identifier in HandlerIdentifier]: (input: HandlerInputById[Identifier]) => Promise<Identifier extends 'init' ? InitApplicationOutcome : CommandOutcome>;
+};
+interface OperatorResetBinding {
+    readonly preview: CommandOutcome;
+    decide(decision: 'approve' | 'decline'): Promise<CommandOutcome>;
+}
+interface OperatorWorkBinding {
+    readonly digest: string;
+    readonly prompt: string;
+    decide(answer: string): Promise<CommandOutcome>;
+}
+export type CliHandlerOverrides = Partial<CommandHandlers> & Readonly<{
+    beginOperatorWorkApplication?: (input: WorkCommandInput) => Promise<OperatorWorkBinding | CommandOutcome>;
+    beginOperatorReset?: (input: ResetCommandInput) => Promise<OperatorResetBinding | CommandOutcome>;
+    loadPolicy?: typeof loadOperatorPolicy;
+    scaffoldCompose?: (input: ComposeScaffoldRequest) => Promise<CommandOutcome>;
+}>;
+/** A validated `init --scaffold-compose` request: the canonical cockpit root and what to write there. */
+export interface ComposeScaffoldRequest {
+    readonly root: string;
+    readonly dir: string;
+    readonly port: number;
+    readonly command?: readonly string[];
+    readonly with: readonly ScaffoldBackingService[];
+}
+export declare function runCli(args: readonly string[], io?: CliIo, handlerOverrides?: CliHandlerOverrides, runtime?: CliRuntime): Promise<number>;
+export {};