orizu 0.5.28 → 0.5.29

package/dist/feedback-cli.js

@@ -0,0 +1,601 @@
+import { closeSync, constants, fstatSync, openSync, readFileSync, realpathSync, } from 'fs';
+import { homedir, release } from 'os';
+import { basename, extname, isAbsolute, relative, resolve, sep, } from 'path';
+import { parseCliProjectSlug } from './cli-project-slug.js';
+import { FEEDBACK_ATTACHMENT_EXTENSIONS, FEEDBACK_CAPS, FROM_FILE_KEYS, hasValidProductFeedbackAttachmentNameSyntax, hasValidProductFeedbackSlugSyntax, isLastErrorRecordShape, PRODUCT_FEEDBACK_ROUTE, PRODUCT_FEEDBACK_UNAUTHENTICATED_MESSAGE, validateProductFeedbackRequest, } from './feedback-contract.js';
+import { getSecretsSeenThisProcess, getConfigDir, getServerCredentials, resolveEnvBearerToken, } from './credentials.js';
+import { scrubFeedbackText, scrubFeedbackValue } from './feedback-scrub.js';
+import { LAST_ERROR_ATTACH_MAX_AGE_MS, readLastErrorRecord, } from './last-error-record.js';
+import { captureAuthenticatedRequestContext } from './http.js';
+import { parseJsonResponse, sanitizeHumanInlineText, sanitizeTerminalText, } from './json-response.js';
+import { existingWorkspaceTeamSlug, getWorkspaceRoot, workspaceExists, } from './workspace.js';
+const VALUE_FLAGS = [
+    '--category',
+    '--severity',
+    '--summary',
+    '--tried',
+    '--expected',
+    '--actual',
+    '--impact',
+    '--repro',
+    '--attach',
+    '--from-file',
+    '--project',
+];
+const REPEATABLE_FLAGS = new Set(['--attach']);
+const FATAL_TEXT_DECODER = new TextDecoder('utf-8', { fatal: true });
+const FROM_FILE_KEY_SET = new Set(FROM_FILE_KEYS);
+const FROM_FILE_MAX_BYTES = 65_536;
+function clientRefusal(code, reason) {
+    return `${code}: ${reason}`;
+}
+function getCliVersion() {
+    const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    if (typeof packageJson.version !== 'string' || packageJson.version.length === 0) {
+        throw new Error('Unable to read orizu CLI version.');
+    }
+    return packageJson.version;
+}
+function safeCliVersion() {
+    try {
+        return getCliVersion();
+    }
+    catch {
+        return null;
+    }
+}
+function expandHomePath(path, homeDirectory) {
+    return path === '~'
+        ? homeDirectory
+        : path.startsWith('~/')
+            ? resolve(homeDirectory, path.slice(2))
+            : path;
+}
+function parseFeedbackArgs(args) {
+    const values = {};
+    const attachments = [];
+    const seen = new Set();
+    let fromFile = null;
+    let project = null;
+    let suppressLastError = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === '--json')
+            continue;
+        if (argument === '--no-last-error') {
+            if (seen.has(argument)) {
+                return clientRefusal('invalid_flag_repeated', '--no-last-error may be given only once');
+            }
+            seen.add(argument);
+            suppressLastError = true;
+            continue;
+        }
+        let flag = argument;
+        let value = null;
+        const equalsIndex = argument.indexOf('=');
+        if (equalsIndex > 0) {
+            flag = argument.slice(0, equalsIndex);
+            value = argument.slice(equalsIndex + 1);
+        }
+        if (!VALUE_FLAGS.includes(flag)) {
+            return clientRefusal('invalid_flag_value', `unknown argument ${argument}`);
+        }
+        if (!REPEATABLE_FLAGS.has(flag) && seen.has(flag)) {
+            return clientRefusal('invalid_flag_repeated', `${flag} may be given only once`);
+        }
+        if (value === null) {
+            const candidate = args[index + 1];
+            if (!candidate)
+                return clientRefusal('invalid_flag_value', `${flag} requires a value`);
+            if (candidate.startsWith('-')) {
+                return clientRefusal('invalid_flag_value', `${flag} needs a value (use ${flag}=<text> for values that start with a dash)`);
+            }
+            value = candidate;
+            index += 1;
+        }
+        if (value.length === 0)
+            return clientRefusal('invalid_flag_value', `${flag} requires a value`);
+        seen.add(flag);
+        if (flag === '--attach')
+            attachments.push(value);
+        else if (flag === '--from-file')
+            fromFile = value;
+        else if (flag === '--project')
+            project = value;
+        else
+            values[flag.slice(2)] = value;
+    }
+    if (attachments.length > FEEDBACK_CAPS.maxAttachments) {
+        return clientRefusal('invalid_attachment_count', `at most ${FEEDBACK_CAPS.maxAttachments} user attachments are allowed`);
+    }
+    return { values, attachments, fromFile, project, suppressLastError };
+}
+function readFromFile(path, homeDirectory) {
+    const expandedPath = expandHomePath(path, homeDirectory);
+    let descriptor;
+    try {
+        descriptor = openSync(expandedPath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    }
+    catch (error) {
+        return error instanceof Error && 'code' in error && error.code === 'ELOOP'
+            ? clientRefusal('invalid_from_file', '--from-file must be a regular file, not a link')
+            : clientRefusal('invalid_from_file_unreadable', '--from-file could not be opened');
+    }
+    let contents;
+    try {
+        const entry = fstatSync(descriptor);
+        if (!entry.isFile()) {
+            return clientRefusal('invalid_from_file', '--from-file must be a regular file');
+        }
+        if (entry.size > FROM_FILE_MAX_BYTES) {
+            return clientRefusal('invalid_from_file', `--from-file exceeds ${FROM_FILE_MAX_BYTES} bytes`);
+        }
+        contents = readFileSync(descriptor, 'utf8');
+    }
+    catch {
+        return clientRefusal('invalid_from_file_unreadable', '--from-file could not be read');
+    }
+    finally {
+        closeSync(descriptor);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch {
+        return clientRefusal('invalid_from_file_json', '--from-file contains invalid JSON');
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return clientRefusal('invalid_from_file_json', '--from-file must contain one JSON object');
+    }
+    const entries = Object.entries(parsed);
+    const unknownEntry = entries.find(([key]) => !FROM_FILE_KEY_SET.has(key));
+    if (unknownEntry) {
+        return clientRefusal('invalid_from_file_json', `--from-file contains unknown field ${unknownEntry[0]}`);
+    }
+    const invalidEntry = entries.find(([, value]) => value !== null && typeof value !== 'string');
+    if (invalidEntry) {
+        return clientRefusal('invalid_from_file_json', `${invalidEntry[0]} must be a string or null`);
+    }
+    return Object.fromEntries(entries);
+}
+function canonicalConfigRoot(configDirectory) {
+    try {
+        return realpathSync(configDirectory);
+    }
+    catch {
+        return resolve(configDirectory);
+    }
+}
+function attachmentIsInsideConfig(path, canonicalConfigDirectory) {
+    const pathFromConfig = relative(canonicalConfigDirectory, path);
+    return pathFromConfig === ''
+        || (pathFromConfig !== '..'
+            && !pathFromConfig.startsWith(`..${sep}`)
+            && !isAbsolute(pathFromConfig));
+}
+function readAttachment(inputPath, attachmentIndex, options) {
+    const resolvedPath = resolve(expandHomePath(inputPath, options.homeDirectory));
+    const name = basename(resolvedPath);
+    if (name.toLowerCase() === 'last-error.json') {
+        return clientRefusal('invalid_attachment_name', 'last-error.json is reserved for the automatic last-error record');
+    }
+    if (!FEEDBACK_ATTACHMENT_EXTENSIONS.includes(extname(name).toLowerCase())) {
+        return clientRefusal('invalid_attachment_extension', `attachment ${name} is not a supported text file`);
+    }
+    let descriptor;
+    try {
+        descriptor = openSync(resolvedPath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    }
+    catch (error) {
+        return error instanceof Error && 'code' in error && error.code === 'ELOOP'
+            ? clientRefusal('invalid_attachment_path', `${name} must be a regular file, not a link or directory`)
+            : clientRefusal('invalid_attachment_unreadable', `cannot open attachment ${name}`);
+    }
+    let bytes;
+    try {
+        const entry = fstatSync(descriptor);
+        if (entry.isFIFO()) {
+            return clientRefusal('invalid_attachment_unreadable', `${name} must not be a pipe`);
+        }
+        if (!entry.isFile()) {
+            return clientRefusal('invalid_attachment_path', `${name} must be a regular file, not a link or directory`);
+        }
+        if (entry.size > FEEDBACK_CAPS.attachmentBytes) {
+            return clientRefusal('too_large_attachment', `${name} exceeds ${FEEDBACK_CAPS.attachmentBytes} bytes`);
+        }
+        const canonicalPath = realpathSync(resolvedPath);
+        if (attachmentIsInsideConfig(canonicalPath, options.canonicalConfigDirectory)) {
+            return clientRefusal('invalid_attachment_path', `${name} is inside the Orizu config directory and cannot be attached`);
+        }
+        bytes = readFileSync(descriptor);
+    }
+    catch {
+        return clientRefusal('invalid_attachment_unreadable', `cannot read attachment ${name}`);
+    }
+    finally {
+        closeSync(descriptor);
+    }
+    let contents;
+    try {
+        contents = FATAL_TEXT_DECODER.decode(bytes);
+    }
+    catch {
+        return clientRefusal('invalid_attachment_content', `${name} is not a UTF-8 text file`);
+    }
+    if (contents.includes('\0')) {
+        return clientRefusal('invalid_attachment_content', `${name} is not a UTF-8 text file`);
+    }
+    const scrubOptions = {
+        reporterEmail: null,
+        homeDir: options.homeDirectory,
+        secrets: options.secrets,
+    };
+    const scrubbed = scrubFeedbackText(contents, scrubOptions);
+    const scrubbedName = scrubFeedbackText(name, scrubOptions);
+    const attachmentName = scrubbedName === name
+        && hasValidProductFeedbackAttachmentNameSyntax(name)
+        ? name
+        : `attachment-${attachmentIndex}${extname(name)}`;
+    if (attachmentName !== name)
+        options.onRename(scrubbedName, attachmentName);
+    return { name: attachmentName, contentBase64: btoa(unescape(encodeURIComponent(scrubbed))) };
+}
+function firstUnusedAttachmentName(extension, attachments) {
+    const usedNames = new Set(attachments.map(attachment => attachment.name.toLowerCase()));
+    for (let number = 1;; number += 1) {
+        const candidate = `attachment-${number}${extension}`;
+        if (!usedNames.has(candidate.toLowerCase()))
+            return candidate;
+    }
+}
+function activeCredentialSecrets(baseUrl) {
+    const credentials = getServerCredentials(baseUrl);
+    if (!credentials)
+        return [];
+    return 'accessToken' in credentials
+        ? [credentials.accessToken, credentials.refreshToken]
+        : [credentials.apiKey];
+}
+function activeCredentialSecretsBestEffort(baseUrl) {
+    try {
+        return activeCredentialSecrets(baseUrl);
+    }
+    catch {
+        return [];
+    }
+}
+function resolveScrubSecrets(baseUrl, envBearer) {
+    return [...new Set([
+            ...(envBearer ? [envBearer] : []),
+            ...getSecretsSeenThisProcess(),
+            ...activeCredentialSecretsBestEffort(baseUrl),
+        ])];
+}
+function currentEnvironmentBearerBestEffort() {
+    try {
+        return resolveEnvBearerToken();
+    }
+    catch {
+        return null;
+    }
+}
+function currentScrubSecrets(baseUrl, initialSecrets) {
+    return [...new Set([
+            ...initialSecrets,
+            ...getSecretsSeenThisProcess(),
+            ...activeCredentialSecretsBestEffort(baseUrl),
+        ])];
+}
+function parsedProjectContext(value) {
+    const parsed = parseCliProjectSlug(value);
+    return parsed
+        && hasValidProductFeedbackSlugSyntax(parsed.teamSlug)
+        && hasValidProductFeedbackSlugSyntax(parsed.projectSlug)
+        ? parsed
+        : null;
+}
+function resolveProjectContext(explicitProject, cwd) {
+    const invalidProject = clientRefusal('invalid_flag_value', '--project must be <team-slug>/<project-slug>');
+    if (explicitProject)
+        return parsedProjectContext(explicitProject) ?? invalidProject;
+    if (process.env.ORIZU_PROJECT) {
+        return parsedProjectContext(process.env.ORIZU_PROJECT) ?? invalidProject;
+    }
+    const workspaceTeam = existingWorkspaceTeamSlug(getWorkspaceRoot(cwd));
+    return { teamSlug: workspaceTeam, projectSlug: null };
+}
+function lastErrorForContext(configDirectory, serverBaseUrl, teamSlug, now, printErr, scrubNotice) {
+    const record = readLastErrorRecord(configDirectory);
+    if (!record || !isLastErrorRecordShape(record))
+        return null;
+    if (teamSlug === null) {
+        printErr('last error not attached: no team context');
+        return null;
+    }
+    if (record.serverBaseUrl !== null && record.serverBaseUrl !== serverBaseUrl) {
+        printErr('last error not attached: recorded for a different server or team');
+        return null;
+    }
+    if (record.teamSlug !== null && record.teamSlug !== teamSlug) {
+        printErr('last error not attached: recorded for a different team');
+        return null;
+    }
+    const recordedAt = Date.parse(record.recordedAt);
+    const age = now - recordedAt;
+    const descriptor = lastErrorDescriptor(record);
+    if (age >= 0 && age <= LAST_ERROR_ATTACH_MAX_AGE_MS)
+        return record;
+    printErr(scrubNotice(`Ignored stale ${descriptor}.`));
+    return null;
+}
+function lastErrorDescriptor(record) {
+    return `last-error record for ${record.command ?? 'unknown'} at ${record.recordedAt}`;
+}
+function scrubLastErrorRecord(record, scrubOptions) {
+    if (record === null)
+        return null;
+    const scrubbed = scrubFeedbackValue(record, scrubOptions);
+    scrubbed.serverBaseUrl = record.serverBaseUrl;
+    scrubbed.teamSlug = record.teamSlug;
+    return scrubbed;
+}
+function runtimeDescription() {
+    const bunRuntime = globalThis.Bun;
+    return bunRuntime
+        ? `bun ${bunRuntime.version}`
+        : `node ${process.versions.node}`;
+}
+function isProductFeedbackSuccess(value) {
+    return value !== null
+        && typeof value === 'object'
+        && typeof value.id === 'string'
+        && value.id.trim().length > 0
+        && typeof value.message === 'string'
+        && value.message.trim().length > 0;
+}
+const INVALID_TOKEN_FILE_MESSAGE = 'invalid_token_file: ORIZU_TOKEN_FILE is set but could not be read; fix the sandbox or email feedback@orizu.ai';
+const DEFAULT_FEEDBACK_TIMEOUT_MS = 30_000;
+const FEEDBACK_TIMEOUT_MESSAGE = `feedback_timeout: no response within ${DEFAULT_FEEDBACK_TIMEOUT_MS / 1_000} s. Email feedback@orizu.ai`;
+const FEEDBACK_STORAGE_UNCERTAINTY_MESSAGE = 'The report may or may not have been stored; retrying can file it twice. Email feedback@orizu.ai';
+function printFeedbackTimeout(printErr) {
+    printErr(FEEDBACK_TIMEOUT_MESSAGE);
+    printErr(FEEDBACK_STORAGE_UNCERTAINTY_MESSAGE);
+}
+export function resolveFeedbackTimeoutMs(baseUrl) {
+    const hostname = new URL(baseUrl).hostname.toLowerCase();
+    const isLoopback = hostname === 'localhost'
+        || hostname === '[::1]'
+        || /^127(?:\.\d{1,3}){3}$/.test(hostname);
+    if (!isLoopback)
+        return DEFAULT_FEEDBACK_TIMEOUT_MS;
+    const configured = Number(process.env.ORIZU_FEEDBACK_TIMEOUT_MS);
+    return Number.isSafeInteger(configured) && configured > 0
+        ? Math.min(configured, DEFAULT_FEEDBACK_TIMEOUT_MS)
+        : DEFAULT_FEEDBACK_TIMEOUT_MS;
+}
+function endpointUnavailableMessage(status) {
+    return `Feedback endpoint unavailable (status ${status}). Email feedback@orizu.ai`;
+}
+function ambiguousEndpointFailureMessage(status) {
+    return `Feedback endpoint unavailable (status ${status}). The report may or may not have been stored; retrying can file it twice. Email feedback@orizu.ai`;
+}
+function isInvalidTokenFileError(error) {
+    return error instanceof Error && error.message.includes('ORIZU_TOKEN_FILE');
+}
+function scrubbedErrorMessage(error, secrets, homeDirectory) {
+    return scrubFeedbackText(error instanceof Error ? error.message : String(error), {
+        reporterEmail: null,
+        homeDir: homeDirectory,
+        secrets,
+    });
+}
+function scrubbedInlineErrorMessage(error, secrets, homeDirectory) {
+    return sanitizeHumanInlineText(sanitizeTerminalText, scrubbedErrorMessage(error, secrets, homeDirectory));
+}
+export async function feedbackCommand(args, io) {
+    const configDirectory = io.configDir ?? getConfigDir();
+    const canonicalConfigDirectory = canonicalConfigRoot(configDirectory);
+    const cwd = io.cwd ?? process.cwd();
+    const homeDirectory = io.homeDir ?? homedir();
+    const now = io.now ?? Date.now;
+    let requestContext;
+    try {
+        requestContext = captureAuthenticatedRequestContext({ pinEnvBearerValue: true });
+    }
+    catch (error) {
+        if (isInvalidTokenFileError(error)) {
+            io.printErr(INVALID_TOKEN_FILE_MESSAGE);
+        }
+        else if (error instanceof Error && error.message.startsWith('Not logged in for ')) {
+            io.printErr(clientRefusal('unauthenticated', PRODUCT_FEEDBACK_UNAUTHENTICATED_MESSAGE));
+        }
+        else {
+            io.printErr(`network_error: ${scrubbedErrorMessage(error, getSecretsSeenThisProcess(), homeDirectory)}. Email feedback@orizu.ai`);
+        }
+        return 1;
+    }
+    const baseUrl = requestContext.baseUrl;
+    const isHosted = requestContext.source !== 'stored';
+    let secrets = resolveScrubSecrets(baseUrl, null);
+    const scrubNotice = (message) => scrubFeedbackText(message, {
+        reporterEmail: null,
+        homeDir: homeDirectory,
+        secrets,
+    });
+    try {
+        const parsed = parseFeedbackArgs(args);
+        if (typeof parsed === 'string') {
+            io.printErr(scrubNotice(parsed));
+            return 1;
+        }
+        const fromFile = parsed.fromFile
+            ? readFromFile(parsed.fromFile, homeDirectory)
+            : {};
+        if (typeof fromFile === 'string') {
+            io.printErr(scrubNotice(fromFile));
+            return 1;
+        }
+        const projectContext = resolveProjectContext(parsed.project, cwd);
+        if (typeof projectContext === 'string') {
+            io.printErr(scrubNotice(projectContext));
+            return 1;
+        }
+        if (parsed.attachments.length > 0 && projectContext.teamSlug === null) {
+            io.printErr(clientRefusal('invalid_attachments', 'attachments need a project: pass --project <team/project> or set ORIZU_PROJECT'));
+            return 1;
+        }
+        const attachments = [];
+        for (const [index, path] of parsed.attachments.entries()) {
+            const attachment = readAttachment(path, index + 1, {
+                canonicalConfigDirectory,
+                homeDirectory,
+                secrets,
+                onRename: (originalName, attachmentName) => {
+                    io.printErr(`attachment renamed: ${originalName} -> ${attachmentName}`);
+                },
+            });
+            if (typeof attachment === 'string') {
+                io.printErr(scrubNotice(attachment));
+                return 1;
+            }
+            let acceptedAttachment = attachment;
+            if (attachments.some(existing => existing.name.toLowerCase() === acceptedAttachment.name.toLowerCase())) {
+                const renamedAttachment = firstUnusedAttachmentName(extname(acceptedAttachment.name), attachments);
+                io.printErr(`attachment renamed: ${acceptedAttachment.name} -> ${renamedAttachment}`);
+                acceptedAttachment = { ...acceptedAttachment, name: renamedAttachment };
+            }
+            attachments.push(acceptedAttachment);
+        }
+        secrets = resolveScrubSecrets(baseUrl, currentEnvironmentBearerBestEffort());
+        const values = { ...fromFile, ...parsed.values };
+        const lastError = parsed.suppressLastError
+            ? null
+            : lastErrorForContext(configDirectory, baseUrl, projectContext.teamSlug, now(), io.printErr, scrubNotice);
+        const scrubOptions = { reporterEmail: null, homeDir: homeDirectory, secrets };
+        const scrubbedFields = scrubFeedbackValue({
+            category: values.category,
+            severity: values.severity,
+            summary: values.summary,
+            actual: values.actual,
+            tried: values.tried ?? null,
+            expected: values.expected ?? null,
+            impact: values.impact ?? null,
+            repro: values.repro ?? null,
+        }, scrubOptions);
+        const requestCandidate = {
+            ...scrubbedFields,
+            lastError: scrubLastErrorRecord(lastError, scrubOptions),
+            environment: {
+                cliVersion: safeCliVersion(),
+                os: `${process.platform} ${release()}`,
+                runtime: runtimeDescription(),
+                serverBaseUrl: baseUrl,
+                hosted: isHosted,
+                teamSlug: projectContext.teamSlug,
+                projectSlug: projectContext.projectSlug,
+                workspaceRootFound: workspaceExists(cwd),
+            },
+        };
+        const validation = validateProductFeedbackRequest({ ...requestCandidate, attachments });
+        if (!validation.ok) {
+            io.printErr(scrubNotice(validation.refusal.message));
+            return 1;
+        }
+        if (lastError !== null) {
+            io.printErr(scrubNotice(`Attached ${lastErrorDescriptor(lastError)}.`));
+        }
+        const fetcher = io.fetcher ?? requestContext.fetch;
+        const feedbackSignal = AbortSignal.timeout(resolveFeedbackTimeoutMs(baseUrl));
+        let response;
+        try {
+            response = await fetcher(PRODUCT_FEEDBACK_ROUTE, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(validation.request),
+                signal: feedbackSignal,
+            });
+        }
+        catch (error) {
+            if (feedbackSignal.aborted) {
+                printFeedbackTimeout(io.printErr);
+                return 1;
+            }
+            throw error;
+        }
+        const responseSecrets = currentScrubSecrets(baseUrl, secrets);
+        let responseBody;
+        try {
+            responseBody = await parseJsonResponse(response, 'Product feedback');
+        }
+        catch {
+            if (feedbackSignal.aborted) {
+                printFeedbackTimeout(io.printErr);
+                return 1;
+            }
+            if (response.status !== 429) {
+                io.printErr(response.status >= 500 && response.status <= 599
+                    ? ambiguousEndpointFailureMessage(response.status)
+                    : endpointUnavailableMessage(response.status));
+                return 1;
+            }
+            responseBody = null;
+        }
+        if (response.status === 429) {
+            const responseError = responseBody !== null
+                && typeof responseBody === 'object'
+                && typeof responseBody.error === 'string'
+                ? responseBody.error
+                : 'rate limited';
+            const detail = responseError.replace(/^rate_limited:\s*/i, '').trim() || 'rate limited';
+            const retryAfter = response.headers.get('Retry-After');
+            const retryInstruction = retryAfter === null
+                ? ''
+                : /^\d+$/.test(retryAfter)
+                    ? `; retry after ${retryAfter} s`
+                    : `; retry at ${retryAfter}`;
+            io.printErr(scrubbedInlineErrorMessage(`rate_limited: ${detail}${retryInstruction}`, responseSecrets, homeDirectory));
+            return 1;
+        }
+        if (!response.ok) {
+            const serverError = responseBody !== null
+                && typeof responseBody === 'object'
+                && typeof responseBody.error === 'string'
+                ? responseBody.error
+                : `Product feedback failed with status ${response.status}.`;
+            if (response.status >= 500 && response.status <= 599) {
+                if (response.status === 500 && /^storage_failed(?:\b|:)/.test(serverError)) {
+                    io.printErr(scrubbedInlineErrorMessage(serverError, responseSecrets, homeDirectory));
+                    io.printErr('Nothing was stored; try again in a minute or email feedback@orizu.ai');
+                }
+                else {
+                    io.printErr(ambiguousEndpointFailureMessage(response.status));
+                }
+                return 1;
+            }
+            io.printErr(scrubbedInlineErrorMessage(serverError, responseSecrets, homeDirectory));
+            return 1;
+        }
+        if (!isProductFeedbackSuccess(responseBody)) {
+            io.printErr(endpointUnavailableMessage(response.status));
+            return 1;
+        }
+        const success = scrubFeedbackValue(responseBody, {
+            ...scrubOptions,
+            secrets: responseSecrets,
+            reporterEmail: 'feedback@orizu.ai',
+        });
+        if (io.json)
+            io.print(JSON.stringify(success));
+        else {
+            io.print(sanitizeHumanInlineText(sanitizeTerminalText, `Reported (id ${success.id}). ${success.message}`));
+        }
+        return 0;
+    }
+    catch (error) {
+        io.printErr(isInvalidTokenFileError(error)
+            ? INVALID_TOKEN_FILE_MESSAGE
+            : `network_error: ${scrubbedErrorMessage(error, currentScrubSecrets(baseUrl, secrets), homeDirectory)}. Email feedback@orizu.ai`);
+        return 1;
+    }
+}

package/dist/feedback-contract.d.ts

@@ -0,0 +1,77 @@
+export declare const FEEDBACK_CATEGORIES: readonly ["bug", "docs", "missing", "guidance", "friction", "other"];
+export type FeedbackCategory = typeof FEEDBACK_CATEGORIES[number];
+export declare const FEEDBACK_SEVERITIES: readonly ["blocking", "major", "minor"];
+export type FeedbackSeverity = typeof FEEDBACK_SEVERITIES[number];
+export declare const FEEDBACK_ATTACHMENT_EXTENSIONS: readonly [".log", ".txt", ".md", ".json"];
+export declare const FEEDBACK_CAPS: {
+    readonly summaryBytes: 200;
+    readonly actualBytes: 1200;
+    readonly triedBytes: 800;
+    readonly expectedBytes: 800;
+    readonly impactBytes: 800;
+    readonly reproBytes: 1200;
+    readonly narrativeTotalBytes: 4000;
+    readonly environmentBytes: 4096;
+    readonly attachmentBytes: 262144;
+    readonly attachmentNameBytes: 128;
+    readonly maxAttachments: 5;
+    readonly bodyBytes: 2097152;
+};
+export declare const PRODUCT_FEEDBACK_FLAGS: readonly ["--category", "--severity", "--summary", "--tried", "--expected", "--actual", "--impact", "--repro", "--attach", "--from-file", "--project", "--no-last-error", "--json"];
+export declare const FROM_FILE_KEYS: string[];
+export interface ProductFeedbackEnvironment {
+    cliVersion: string | null;
+    os: string;
+    runtime: string;
+    serverBaseUrl: string;
+    hosted: boolean;
+    teamSlug: string | null;
+    projectSlug: string | null;
+    workspaceRootFound: boolean;
+}
+export interface ProductFeedbackAttachment {
+    name: string;
+    contentBase64: string;
+}
+export interface ProductFeedbackRequest {
+    category: FeedbackCategory;
+    severity: FeedbackSeverity;
+    summary: string;
+    actual: string;
+    tried: string | null;
+    expected: string | null;
+    impact: string | null;
+    repro: string | null;
+    environment: ProductFeedbackEnvironment;
+    lastError: unknown | null;
+    attachments: ProductFeedbackAttachment[];
+}
+export declare const FEEDBACK_REFUSAL_CODES: readonly ["invalid_json", "invalid_category", "invalid_severity", "invalid_summary", "invalid_actual", "invalid_tried", "invalid_expected", "invalid_impact", "invalid_repro", "invalid_environment", "invalid_last_error", "invalid_attachment_name", "invalid_attachment_count", "invalid_attachment_content", "invalid_attachments", "too_large_summary", "too_large_actual", "too_large_tried", "too_large_expected", "too_large_impact", "too_large_repro", "too_large_narrative", "too_large_environment", "too_large_attachment", "too_large_body"];
+export type FeedbackRefusalCode = typeof FEEDBACK_REFUSAL_CODES[number];
+export interface FeedbackRefusal {
+    code: FeedbackRefusalCode;
+    message: string;
+}
+export type ValidateProductFeedbackResult = {
+    ok: true;
+    request: ProductFeedbackRequest;
+} | {
+    ok: false;
+    refusal: FeedbackRefusal;
+};
+export declare const FEEDBACK_CLIENT_REFUSAL_CODES: readonly ["invalid_flag_repeated", "invalid_flag_value", "invalid_attachment_path", "invalid_attachment_extension", "invalid_attachment_unreadable", "invalid_from_file", "invalid_from_file_unreadable", "invalid_from_file_json", "invalid_token_file", "unauthenticated", "network_error", "feedback_timeout"];
+export declare const FEEDBACK_SERVER_REFUSAL_PREFIXES: readonly ["unauthorized", "forbidden", "rate_limited", "storage_failed"];
+export declare const PRODUCT_FEEDBACK_ROUTE = "/api/cli/feedback";
+export declare const PRODUCT_FEEDBACK_MESSAGE = "Thanks, this has been reported. To follow up, email feedback@orizu.ai";
+export declare const PRODUCT_FEEDBACK_UNAUTHENTICATED_MESSAGE = "Sign in first (orizu login) or email feedback@orizu.ai";
+export interface ProductFeedbackSuccess {
+    id: string;
+    message: string;
+}
+export declare function hasValidProductFeedbackAttachmentNameSyntax(value: unknown): value is string;
+export declare function hasValidProductFeedbackSlugSyntax(value: unknown): value is string;
+export declare function isLastErrorRecordShape(value: unknown): boolean;
+export declare function decodedBase64Bytes(value: string): number | null;
+export declare function feedbackRefusalStatus(code: FeedbackRefusalCode): 400 | 413;
+export declare function validateProductFeedbackRequest(input: unknown): ValidateProductFeedbackResult;
+//# sourceMappingURL=feedback-contract.d.ts.map

package/dist/feedback-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback-contract.d.ts","sourceRoot":"","sources":["../src/feedback-contract.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,mBAAmB,sEAOtB,CAAA;AAEV,MAAM,MAAM,gBAAgB,GAAG,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAA;AAEjE,eAAO,MAAM,mBAAmB,yCAA0C,CAAA;AAE1E,MAAM,MAAM,gBAAgB,GAAG,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAA;AAEjE,eAAO,MAAM,8BAA8B,2CAA4C,CAAA;AAEvF,eAAO,MAAM,aAAa;;;;;;;;;;;;;CAahB,CAAA;AAEV,eAAO,MAAM,sBAAsB,qLAczB,CAAA;AAGV,eAAO,MAAM,cAAc,UAEE,CAAA;AAE7B,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,kBAAkB,EAAE,OAAO,CAAA;CAC5B;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,WAAW,EAAE,0BAA0B,CAAA;IACvC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAA;IACzB,WAAW,EAAE,yBAAyB,EAAE,CAAA;CACzC;AAED,eAAO,MAAM,sBAAsB,4hBA0BzB,CAAA;AAEV,MAAM,MAAM,mBAAmB,GAAG,OAAO,sBAAsB,CAAC,MAAM,CAAC,CAAA;AAEvE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,MAAM,6BAA6B,GACrC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,sBAAsB,CAAA;CAAE,GAC7C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAE,CAAA;AAE3C,eAAO,MAAM,6BAA6B,mTAahC,CAAA;AAEV,eAAO,MAAM,gCAAgC,0EAKnC,CAAA;AAEV,eAAO,MAAM,sBAAsB,sBAAsB,CAAA;AACzD,eAAO,MAAM,wBAAwB,0EAA0E,CAAA;AAC/G,eAAO,MAAM,wCAAwC,2DAA2D,CAAA;AAEhH,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;CAChB;AAqCD,wBAAgB,2CAA2C,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE3F;AA0CD,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEjF;AAoDD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAyB9D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgB/D;AAaD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,GAAG,GAAG,GAAG,GAAG,CAE1E;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,6BAA6B,CAuH5F"}