@userreason/cli 0.1.0 → 0.2.0

package/dist/setup-wire.js

@@ -0,0 +1,175 @@
+// Public packages cannot depend on the private contracts package. These bounded
+// readers mirror @userreason/ur-types/setup/v1; conformance tests check both.
+import { SetupError } from './setup-store.js';
+const fail = () => { throw new SetupError('invalid_setup_response', 'Invalid setup protocol data. Update compatible clients or start a new setup; no further local effects will be applied.'); };
+const text = (min, max, pattern) => value => typeof value === 'string' && value.length >= min && value.length <= max && (!pattern || pattern.test(value)) ? value : fail();
+const bool = value => typeof value === 'boolean' ? value : fail();
+const literal = (expected) => value => value === expected ? expected : fail();
+const oneOf = (values) => value => typeof value === 'string' && values.includes(value) ? value : fail();
+const integer = (min, max) => value => typeof value === 'number' && Number.isInteger(value) && value >= min && value <= max ? value : fail();
+const nullable = (read) => value => value === null ? null : read(value);
+const optional = (read) => value => value === undefined ? undefined : read(value);
+const array = (read, min, max, key) => value => {
+    if (!Array.isArray(value) || value.length < min || value.length > max)
+        return fail();
+    const parsed = value.map(read);
+    if (key && new Set(parsed.map(key)).size !== parsed.length)
+        return fail();
+    return parsed;
+};
+const shape = (fields) => value => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return fail();
+    const input = value;
+    if (Object.keys(input).some(key => !Object.hasOwn(fields, key)))
+        return fail();
+    const out = {};
+    for (const [key, read] of Object.entries(fields)) {
+        const parsed = read(input[key]);
+        if (parsed !== undefined)
+            out[key] = parsed;
+    }
+    return out;
+};
+const refine = (read, check) => value => { const parsed = read(value); return check(parsed) ? parsed : fail(); };
+const bounded = (read) => value => {
+    let encoded;
+    try {
+        encoded = JSON.stringify(value);
+    }
+    catch {
+        return fail();
+    }
+    if (encoded === undefined || Buffer.byteLength(encoded) > 65_536)
+        return fail();
+    return read(value);
+};
+const uuid = text(36, 36, /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i);
+const hash = text(64, 64, /^[a-f0-9]{64}$/);
+const timestamp = refine(text(20, 65536, /^\d{4}-\d{2}-\d{2}T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/), value => {
+    const day = value.slice(0, 10), date = new Date(`${day}T00:00:00Z`);
+    return Number.isFinite(Date.parse(value)) && Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === day;
+});
+const revision = refine(text(1, 19, /^[1-9][0-9]*$/), value => BigInt(value) <= 9223372036854775807n);
+const generation = integer(1, 2147483647);
+const shortText = value => text(1, 240, /^[^\u0000-\u001f\u007f]*$/)(typeof value === 'string' ? value.trim() : value);
+const identifier = text(1, 80, /^[A-Za-z0-9_-]+$/);
+const relativePath = refine(text(1, 240), value => !value.startsWith('/') && !/[\\:\u0000-\u001f\u007f]/.test(value) && value.split('/').every(part => !['', '.', '..'].includes(part)));
+const scope = { schema_version: literal(1), setup_id: uuid };
+export const setupPhases = ['configuring', 'awaiting_local_approval', 'applying', 'ready_for_recommendations', 'analyzing', 'selecting_drafts', 'creating_drafts', 'agent_test', 'complete', 'cancelled', 'expired'];
+export const setupEffectKinds = ['install_packages', 'initialize_sdk', 'install_skill', 'insert_footer'];
+const resultCodes = ['verified', 'already_present', 'skipped', 'review_required', 'unsupported', 'dependency_failed', 'operation_failed', 'cancelled', 'outcome_unknown'];
+const statuses = ['prepared', 'approved', 'leased', 'running', 'succeeded', 'failed', 'manual', 'cancelled', 'outcome_unknown'];
+export const parseSetupCapabilities = shape({
+    framework: oneOf(['react', 'next', 'vue', 'vanilla']), package_manager: oneOf(['npm', 'pnpm', 'yarn']),
+    install_packages: bool, initialize_sdk: bool, install_skill: bool, insert_footer: bool, source_review: bool, sample_read: bool,
+    project_name: optional(refine(shortText, value => value.length <= 120 && !/[\/\\]/.test(value))),
+    terminal: optional(shape({ platform: oneOf(['macos', 'windows', 'linux', 'other']), app: oneOf(['apple_terminal', 'iterm2', 'windows_terminal', 'vscode', 'cursor', 'warp', 'ghostty', 'wezterm', 'alacritty', 'kitty', 'generic']) })),
+});
+const choices = shape({ install_sdk: bool, install_skill: bool, footer_badge: bool });
+const fileChange = shape({ path: relativePath, before_hash: nullable(hash), after_hash: hash });
+const files = array(fileChange, 1, 16, value => value.path);
+const managedOutput = shape({ path: oneOf(['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', '.pnp.cjs', '.pnp.loader.mjs']), before_hash: nullable(hash) });
+const effectReaders = {
+    install_packages: refine(shape({ effect_id: uuid, kind: literal('install_packages'), package_manager: oneOf(['npm', 'pnpm', 'yarn']), packages: array(shape({ name: oneOf(['@userreason/js', '@userreason/cli']), version: text(1, 80, /^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?(?:\+[A-Za-z0-9.-]+)?$/) }), 1, 2, value => value.name), files, managed_outputs: optional(array(managedOutput, 0, 5, value => value.path)) }), value => !(value.managed_outputs ?? []).some(output => value.files.some(file => file.path === output.path))),
+    initialize_sdk: shape({ effect_id: uuid, kind: literal('initialize_sdk'), site_id: uuid, files }),
+    install_skill: shape({ effect_id: uuid, kind: literal('install_skill'), files }),
+    insert_footer: shape({ effect_id: uuid, kind: literal('insert_footer'), files, placement: shape({ path: relativePath, anchor_hash: hash }) }),
+};
+const effect = value => {
+    const kind = value?.kind;
+    if (typeof kind !== 'string' || !Object.hasOwn(effectReaders, kind))
+        return fail();
+    return effectReaders[kind](value);
+};
+const manualStep = shape({ kind: oneOf(setupEffectKinds), code: oneOf(['unsupported', 'review_required', 'dependency_failed']) });
+const localPlan = refine(bounded(shape({ project_fingerprint: hash, choices_digest: hash, effects: array(effect, 0, 32, value => value.effect_id), manual_steps: optional(array(manualStep, 0, 4, value => value.kind)) })), value => Buffer.byteLength(JSON.stringify(value)) <= 16_384 && !(value.manual_steps ?? []).some(step => value.effects.some(effect => effect.kind === step.kind)));
+const effectResult = refine(shape({ code: oneOf(resultCodes), verified: optional(bool) }), value => ['verified', 'already_present'].includes(value.code) === (value.verified === true));
+const command = refine(shape({
+    operation_id: uuid, sequence: integer(1, 32), kind: oneOf(setupEffectKinds), expected_revision: revision,
+    input: effect, input_digest: hash, approval_digest: hash, status: oneOf(statuses), executor_generation: nullable(generation),
+    lease_generation: integer(0, 2147483647), lease_expires_at: nullable(timestamp), result: nullable(effectResult), result_digest: nullable(hash),
+    created_at: timestamp, started_at: nullable(timestamp), finished_at: nullable(timestamp), updated_at: timestamp,
+}), value => value.kind === value.input.kind && (value.result === null) === (value.result_digest === null) &&
+    (!['leased', 'running'].includes(value.status) || (value.executor_generation !== null && value.lease_generation > 0 && value.lease_expires_at !== null)) &&
+    (value.status !== 'succeeded' || value.result?.verified === true));
+export function parseSetupLocalPlan(value) { return localPlan(value); }
+export function parseSetupEffect(value) { return effect(value); }
+const sampleState = refine(shape({ status: oneOf(['not_started', 'waiting', 'received', 'skipped']), first_received_at: nullable(timestamp), latest_received_at: nullable(timestamp), latest_request_id: nullable(uuid) }), value => (value.first_received_at === null) === (value.latest_received_at === null) && (value.latest_received_at === null) === (value.latest_request_id === null) && (value.status !== 'received' || value.first_received_at !== null));
+const draftOutcome = refine(shape({ candidate_id: identifier, status: oneOf(['pending', 'succeeded', 'failed']), prompt_id: uuid, request_id: uuid, revision: nullable(revision), code: nullable(oneOf(resultCodes)) }), value => value.status !== 'succeeded' || value.revision !== null);
+const sourceErrors = ['planning_unavailable', 'planning_paused', 'planning_daily_budget', 'planning_allowance_exhausted', 'planning_provider_unavailable', 'planning_policy_changed', 'planning_consent_expired', 'planning_input_budget', 'planning_invalid_output', 'planning_timeout', 'source_changed', 'source_unavailable', 'recommendations_no_source', 'operation_failed'];
+const sourceState = refine(shape({ preparation_id: uuid, status: oneOf(['pending', 'approved', 'analyzing', 'ready', 'failed', 'skipped']), packet_digest: hash, provider_fingerprint: hash, authorized_at: nullable(timestamp), expires_at: timestamp, error_code: nullable(oneOf(sourceErrors)) }), value => (!['approved', 'analyzing', 'ready'].includes(value.status) || value.authorized_at !== null) && (value.authorized_at === null || Date.parse(value.expires_at) > Date.parse(value.authorized_at) && Date.parse(value.expires_at) - Date.parse(value.authorized_at) <= 600_000));
+const sourceFile = refine(shape({ path: relativePath, file_hash: hash, excerpt_hash: hash, bytes: integer(0, 12000), start_line: integer(1, Number.MAX_SAFE_INTEGER), end_line: integer(1, Number.MAX_SAFE_INTEGER) }), value => value.end_line >= value.start_line);
+export const parseSetupSourceManifest = refine(bounded(shape({ packet_digest: hash, snapshot_id: uuid, files: array(sourceFile, 0, 200, value => value.path), omitted_files: integer(0, 1000000), truncated: bool, git_included: literal(false) })), value => value.files.reduce((sum, file) => sum + file.bytes, 0) <= 12000);
+const sourcePackage = shape({ name: (value) => text(1, 100)(typeof value === 'string' ? value.trim() : value), version: (value) => text(1, 100)(typeof value === 'string' ? value.trim() : value) });
+const sourcePackages = array(sourcePackage, 0, 30, value => value.name);
+const evidencePath = refine(text(1, 500), value => !value.startsWith('/') && !value.includes('\\') && !value.split('/').some(part => ['', '.', '..'].includes(part)));
+const sourceEvidence = refine(shape({ kind: literal('local_source'), id: identifier, path: evidencePath, file_hash: hash, excerpt_hash: hash, snapshot_id: uuid, start_line: integer(1, Number.MAX_SAFE_INTEGER), end_line: integer(1, Number.MAX_SAFE_INTEGER), excerpt: text(0, 12000) }), value => value.end_line >= value.start_line && value.excerpt.split('\n').length === value.end_line - value.start_line + 1);
+const planningLimits = shape({ input_tokens: integer(256, 12000), output_tokens: integer(256, 4000), deadline_ms: integer(1000, 40000) });
+const providerDestination = refine(text(1, 200), value => { try {
+    const url = new URL(value);
+    return url.protocol === 'https:' && !url.username && !url.password && !url.search && !url.hash;
+}
+catch {
+    return false;
+} });
+const price = text(1, 12, /^[1-9]\d{0,11}$/);
+const planningConfiguration = shape({ configuration_fingerprint: hash, providers: array(shape({ role: oneOf(['extraction', 'recommendations']), destination: providerDestination, model: text(1, 200), prices: shape({ input_microUSD_per_million: price, output_microUSD_per_million: price }) }), 1, 2, value => value.role), policy: text(1, 8000), retention: literal('private-plan-7-days;source-not-stored;store-false'), limits: planningLimits });
+export const parseSetupSession = bounded(refine(shape({
+    ...scope, phase: oneOf(setupPhases), revision, workspace_id: nullable(uuid), site_id: nullable(uuid), project_fingerprint: hash,
+    choices, capabilities: parseSetupCapabilities, local_plan: nullable(localPlan), plan_digest: nullable(hash), commands: array(command, 0, 32),
+    executor_generation: generation, connection: oneOf(['connected', 'disconnected']), heartbeat_at: nullable(timestamp),
+    source: optional(nullable(sourceState)), recommendation_digest: optional(nullable(hash)), selected_candidates: optional(array(identifier, 0, 3, value => value)),
+    sample: sampleState, draft_outcomes: array(draftOutcome, 0, 3), bound_at: timestamp, last_activity_at: timestamp,
+    idle_expires_at: timestamp, absolute_expires_at: timestamp, terminal_at: nullable(timestamp),
+}), value => (value.workspace_id === null) === (value.site_id === null) && (value.local_plan === null) === (value.plan_digest === null) &&
+    new Set(value.commands.map(command => command.operation_id)).size === value.commands.length && new Set(value.commands.map(command => command.sequence)).size === value.commands.length &&
+    ['complete', 'cancelled', 'expired'].includes(value.phase) === (value.terminal_at !== null) &&
+    Date.parse(value.bound_at) <= Date.parse(value.last_activity_at) && Date.parse(value.idle_expires_at) <= Date.parse(value.absolute_expires_at) &&
+    Date.parse(value.absolute_expires_at) > Date.parse(value.bound_at) && Date.parse(value.absolute_expires_at) - Date.parse(value.bound_at) <= 7_200_000));
+export const parseSetupDiscovery = shape({ schema_version: literal(1), browser_setup: shape({ versions: array(literal(1), 1, 1), enabled: bool, source_analysis: bool, draft_creation: bool, sample_read: bool }) });
+export const parseSetupStartInput = bounded(shape({ schema_version: literal(1), challenge: hash, project_fingerprint: hash, capabilities: parseSetupCapabilities }));
+export const parseSetupStartResult = shape({ ...scope, ticket: text(1, 16384), browser_url: refine(text(1, 20000), value => { try {
+        new URL(value);
+        return true;
+    }
+    catch {
+        return false;
+    } }), code: text(8, 8, /^[A-F0-9]{8}$/), expires_at: timestamp });
+export const parseSetupExchangeInput = shape({ ...scope, ticket: text(1, 16384), verifier: hash });
+export const parseSetupExchangeResult = bounded(value => {
+    const status = value?.status;
+    if (status === 'pending' || status === 'rejected')
+        return shape({ schema_version: literal(1), status: literal(status) })(value);
+    if (status === 'approved')
+        return shape({ schema_version: literal(1), status: literal('approved'), access_token: text(1, 16384), expires_at: timestamp, session: parseSetupSession })(value);
+    return fail();
+});
+export const parseSetupPollInput = shape(scope);
+export const parseSetupLocalPlanInput = bounded(shape({ ...scope, request_id: uuid, expected_revision: revision, plan: localPlan }));
+export const parseSetupSourceInfoInput = shape(scope);
+export const parseSetupSourcePlanInput = refine(bounded(shape({ ...scope, request_id: uuid, expected_revision: revision, manifest: parseSetupSourceManifest, packages: sourcePackages })), value => value.request_id === value.manifest.snapshot_id);
+export const parseSetupSourceUploadInput = refine(bounded(shape({ ...scope, preparation_id: uuid, project_fingerprint: hash, evidence: array(sourceEvidence, 0, 220, value => value.id) })), value => new Set(value.evidence.map(item => item.path)).size === value.evidence.length && Buffer.byteLength(JSON.stringify(value.evidence)) <= 12000 && value.evidence.every(item => item.snapshot_id === value.preparation_id));
+export const parseSetupSourceInfo = refine(bounded(shape({ schema_version: literal(1), session: parseSetupSession, preparation: nullable(shape({ preparation_id: uuid, manifest: parseSetupSourceManifest, packages: sourcePackages, configuration: planningConfiguration })) })), value => value.preparation === null || value.preparation.preparation_id === value.preparation.manifest.snapshot_id);
+export const parseSetupClaimInput = shape({ ...scope, request_id: uuid, executor_generation: generation });
+export const parseSetupClaimResult = bounded(shape({ schema_version: literal(1), command: nullable(command), session: parseSetupSession }));
+const leased = { ...scope, operation_id: uuid, executor_generation: generation, lease_generation: generation };
+export const parseSetupStartCommandInput = shape(leased);
+const agrees = (value) => value.status === 'succeeded'
+    ? value.result.verified === true && ['verified', 'already_present'].includes(value.result.code)
+    : value.result.verified !== true && !['verified', 'already_present'].includes(value.result.code);
+export const parseSetupCommandResultInput = refine(shape({ ...leased, status: oneOf(['succeeded', 'failed', 'manual']), result: effectResult }), agrees);
+export const parseSetupHeartbeatInput = refine(shape({ ...scope, executor_generation: generation, operation_id: nullable(uuid), lease_generation: nullable(generation) }), value => (value.operation_id === null) === (value.lease_generation === null));
+export const parseSetupReconcileInput = refine(shape({ ...scope, request_id: uuid, project_fingerprint: hash, executor_generation: generation, operation_id: uuid, input_digest: hash, result: effectResult, status: oneOf(['succeeded', 'failed', 'manual']) }), agrees);
+export const parseSetupSampleReadInput = shape({ ...scope, request_id: uuid });
+export const parseSetupSampleReadResult = shape({ ...scope, sample: literal(true), dataset_version: literal('setup-sample-v1'), received_at: timestamp, answers: array(shape({ id: text(8, 8, /^sample-[1-3]$/), question: shortText, answer: shortText }), 3, 3, value => value.id) });
+/** Deliberately public for compatibility tests; the wire source of truth stays in ur-types. */
+export const setupWireReaders = {
+    SetupSourceInfoInput: parseSetupSourceInfoInput, SetupSourcePlanInput: parseSetupSourcePlanInput, SetupSourceUploadInput: parseSetupSourceUploadInput, SetupSourceInfo: parseSetupSourceInfo, SetupSourceManifest: parseSetupSourceManifest,
+    SetupCapabilities: parseSetupCapabilities, SetupSessionView: parseSetupSession, SetupDiscovery: parseSetupDiscovery,
+    SetupStartInput: parseSetupStartInput, SetupStartResult: parseSetupStartResult, SetupExchangeInput: parseSetupExchangeInput,
+    SetupExchangeResult: parseSetupExchangeResult, SetupPollInput: parseSetupPollInput, SetupLocalPlanInput: parseSetupLocalPlanInput,
+    SetupClaimInput: parseSetupClaimInput, SetupClaimResult: parseSetupClaimResult, SetupStartCommandInput: parseSetupStartCommandInput,
+    SetupCommandResultInput: parseSetupCommandResultInput, SetupHeartbeatInput: parseSetupHeartbeatInput, SetupReconcileInput: parseSetupReconcileInput,
+    SetupSampleReadInput: parseSetupSampleReadInput, SetupSampleReadResult: parseSetupSampleReadResult,
+};