orizu 0.0.9 → 0.1.1

package/dist/jsonl-stream.js

@@ -0,0 +1,91 @@
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
+export const JSONL_UPLOAD_CHUNK_MAX_BYTES = 2 * 1024 * 1024;
+function isObjectRow(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function rowsPayloadByteLength(rowCount, rowsByteLength) {
+    return Buffer.byteLength('{"rows":[]}', 'utf8') +
+        rowsByteLength +
+        Math.max(0, rowCount - 1);
+}
+function formatMb(byteLength) {
+    return (byteLength / (1024 * 1024)).toFixed(1);
+}
+function mapReadError(filePath, error) {
+    const maybeError = error;
+    if (!maybeError.code && error instanceof Error) {
+        return error;
+    }
+    if (maybeError.code === 'ENOENT') {
+        return new Error(`File not found: ${filePath}. Check the path and filename, then retry.`);
+    }
+    if (maybeError.code === 'EPERM' || maybeError.code === 'EACCES') {
+        return new Error(`Cannot read file: ${filePath}. macOS may be blocking access to this folder (for example Downloads). Grant folder permission to your terminal app and retry.`);
+    }
+    return new Error(`Failed to read file ${filePath}: ${maybeError.message}`);
+}
+export function estimateRowsPayloadByteLength(rows) {
+    const rowsByteLength = rows.reduce((total, row) => {
+        return total + Buffer.byteLength(JSON.stringify(row), 'utf8');
+    }, 0);
+    return rowsPayloadByteLength(rows.length, rowsByteLength);
+}
+export async function* streamJsonlRowChunks(filePath, options = {}) {
+    const maxPayloadBytes = options.maxPayloadBytes ?? JSONL_UPLOAD_CHUNK_MAX_BYTES;
+    let chunk = [];
+    let chunkRowsByteLength = 0;
+    let parsedRowCount = 0;
+    let lineNumber = 0;
+    const stream = createReadStream(filePath, { encoding: 'utf8' });
+    const lines = createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of lines) {
+            lineNumber += 1;
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                throw new Error(`Invalid JSONL at line ${lineNumber}`);
+            }
+            if (!isObjectRow(parsed)) {
+                throw new Error(`Row ${lineNumber} must be a JSON object`);
+            }
+            const jsonByteLength = Buffer.byteLength(JSON.stringify(parsed), 'utf8');
+            const singleRowPayloadBytes = rowsPayloadByteLength(1, jsonByteLength);
+            if (singleRowPayloadBytes > maxPayloadBytes) {
+                throw new Error(`Row ${lineNumber} is ${formatMb(singleRowPayloadBytes)} MB after JSON encoding, which exceeds the ${formatMb(maxPayloadBytes)} MB upload chunk limit`);
+            }
+            const nextPayloadBytes = rowsPayloadByteLength(chunk.length + 1, chunkRowsByteLength + jsonByteLength);
+            if (chunk.length > 0 && nextPayloadBytes > maxPayloadBytes) {
+                yield chunk.map(item => item.row);
+                chunk = [];
+                chunkRowsByteLength = 0;
+            }
+            chunk.push({ row: parsed, jsonByteLength });
+            chunkRowsByteLength += jsonByteLength;
+            parsedRowCount += 1;
+        }
+    }
+    catch (error) {
+        throw mapReadError(filePath, error);
+    }
+    finally {
+        lines.close();
+        stream.destroy();
+    }
+    if (chunk.length > 0) {
+        yield chunk.map(item => item.row);
+    }
+    if (parsedRowCount === 0) {
+        throw new Error('Dataset file contains no rows');
+    }
+}

package/dist/task-create-error.js

@@ -0,0 +1,60 @@
+function createCliError(message, httpStatus, structuredPayload) {
+    const error = new Error(message);
+    error.httpStatus = httpStatus;
+    error.structuredPayload = structuredPayload;
+    return error;
+}
+export async function formatTaskCreateError(response) {
+    const contentType = response.headers.get('content-type') || '';
+    const rawBody = await response.text();
+    const httpStatus = response.status;
+    let parsedPayload;
+    if (!contentType.includes('application/json')) {
+        return createCliError(`Failed to create task: ${rawBody}`, httpStatus);
+    }
+    try {
+        const payload = JSON.parse(rawBody);
+        parsedPayload = payload;
+        if (Array.isArray(payload.invalidAssigneeErrors) &&
+            payload.invalidAssigneeErrors.length > 0) {
+            const details = payload.invalidAssigneeErrors
+                .filter(item => typeof item.assignee === 'string' &&
+                item.assignee.length > 0 &&
+                typeof item.reason === 'string' &&
+                item.reason.length > 0)
+                .map(item => `  - ${item.assignee}: ${item.reason}`)
+                .join('\n');
+            if (details) {
+                return createCliError(`Failed to create task: ${payload.error || 'Invalid assignees'}\n${details}`, httpStatus, parsedPayload);
+            }
+        }
+        if (Array.isArray(payload.missingRequiredFields) &&
+            payload.missingRequiredFields.length > 0) {
+            const lines = [
+                `Failed to create task: ${payload.error || 'Dataset incompatible'}`,
+            ];
+            if (payload.versionNum !== undefined) {
+                lines.push(`  Version: v${payload.versionNum} (${payload.versionId || 'unknown'})`);
+            }
+            lines.push(`  Missing required fields: ${payload.missingRequiredFields.join(', ')}`);
+            if (typeof payload.incompatibleRowCount === 'number') {
+                lines.push(`  Incompatible rows: ${payload.incompatibleRowCount}`);
+            }
+            if (payload.missingRequiredFieldCounts &&
+                Object.keys(payload.missingRequiredFieldCounts).length > 0) {
+                const fieldCounts = Object.entries(payload.missingRequiredFieldCounts)
+                    .map(([field, count]) => `    ${field}: ${count} rows`)
+                    .join('\n');
+                lines.push(`  Missing field counts:\n${fieldCounts}`);
+            }
+            return createCliError(lines.join('\n'), httpStatus, parsedPayload);
+        }
+        if (typeof payload.error === 'string' && payload.error.length > 0) {
+            return createCliError(`Failed to create task: ${payload.error}`, httpStatus, parsedPayload);
+        }
+    }
+    catch {
+        return createCliError(`Failed to create task: ${rawBody}`, httpStatus);
+    }
+    return createCliError(`Failed to create task: ${rawBody}`, httpStatus, parsedPayload);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orizu",
-  "version": "0.0.9",
+  "version": "0.1.1",
   "private": false,
   "type": "module",
   "bin": {

package/src/credentials.ts

@@ -82,7 +82,15 @@ export function loadCredentialsConfig(): StoredCredentialsV2 | null {
   }
 
   const raw = readFileSync(path, 'utf-8')
-  const parsed = JSON.parse(raw) as unknown
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    console.warn('Warning: credentials file contains invalid JSON — please re-login with `orizu login`')
+    return null
+  }
+
   if (isStoredCredentialsV2(parsed)) {
     return parsed
   }
@@ -91,7 +99,8 @@ export function loadCredentialsConfig(): StoredCredentialsV2 | null {
     return migrateToV2(parsed)
   }
 
-  throw new Error('Invalid credentials file format.')
+  console.warn('Warning: credentials file has unrecognized format — please re-login with `orizu login`')
+  return null
 }
 
 export function getServerCredentials(baseUrl: string): ServerCredentials | null {

package/src/error-response.ts

@@ -0,0 +1,27 @@
+interface ErrorResponsePayload {
+  error?: string
+}
+
+export async function extractErrorMessage(response: Response): Promise<string> {
+  const contentType = response.headers.get('content-type') || ''
+  const rawBody = await response.text()
+
+  if (contentType.includes('application/json')) {
+    try {
+      const payload = JSON.parse(rawBody) as ErrorResponsePayload | null
+      if (
+        payload &&
+        typeof payload === 'object' &&
+        !Array.isArray(payload) &&
+        typeof payload.error === 'string' &&
+        payload.error.length > 0
+      ) {
+        return payload.error
+      }
+    } catch {
+      // Fall through to raw body
+    }
+  }
+
+  return rawBody
+}