orizu 0.0.9 → 0.1.1

package/dist/credentials.js

@@ -68,14 +68,22 @@ export function loadCredentialsConfig() {
         return null;
     }
     const raw = readFileSync(path, 'utf-8');
-    const parsed = JSON.parse(raw);
+    let parsed;
+    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;
     }
     if (isStoredCredentialsV1(parsed)) {
         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) {
     const config = loadCredentialsConfig();

package/dist/error-response.js

@@ -0,0 +1,20 @@
+export async function extractErrorMessage(response) {
+    const contentType = response.headers.get('content-type') || '';
+    const rawBody = await response.text();
+    if (contentType.includes('application/json')) {
+        try {
+            const payload = JSON.parse(rawBody);
+            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;
+}

package/dist/index.js

@@ -1,18 +1,20 @@
 #!/usr/bin/env node
 import { createHash, randomBytes } from 'crypto';
-import { basename } from 'path';
+import { basename, extname } from 'path';
 import { createServer } from 'http';
-import { readFileSync, writeFileSync } from 'fs';
+import { readFileSync, statSync, writeFileSync } from 'fs';
 import { spawn } from 'child_process';
 import { createInterface } from 'readline/promises';
 import { stdin as input, stdout as output } from 'process';
 import { clearServerCredentials, getServerCredentials, saveServerCredentials } from './credentials.js';
 import { parseDatasetFile } from './file-parser.js';
+import { streamJsonlRowChunks } from './jsonl-stream.js';
 import { parseDatasetReference } from './dataset-download.js';
 import { parseGlobalFlags } from './global-flags.js';
 import { authedFetch, getBaseUrl, resolveLoginBaseUrl, setGlobalFlags } from './http.js';
+import { formatTaskCreateError } from './task-create-error.js';
 function printUsage() {
-    console.log(`orizu global options:\n\n  --local                 Use http://localhost:3000\n  --server <url>          Use a specific server origin (for example: https://preview.example.com)\n\norizu commands:\n\n  orizu login\n  orizu logout\n  orizu whoami\n  orizu teams list\n  orizu teams create [--name <name>]\n  orizu teams members list [--team <teamSlug>]\n  orizu teams members add --email <email> [--team <teamSlug>]\n  orizu teams members remove --email <email> [--team <teamSlug>]\n  orizu teams members role --team <teamSlug> --email <email> --role <admin|member>\n  orizu projects list [--team <teamSlug>]\n  orizu projects create --name <name> [--team <teamSlug>]\n  orizu apps list [--project <team/project>]\n  orizu apps create --project <team/project> --name <name> --dataset <datasetId> --file <path> --input-schema <json-path> --output-schema <json-path> [--component <name>]\n  orizu apps update [--app <appId>] [--project <team/project>] --file <path> --input-schema <json-path> --output-schema <json-path> [--component <name>]\n  orizu apps link-dataset --dataset <datasetId> [--app <appId>] [--project <team/project>] [--version <n>]\n  orizu tasks list [--project <team/project>]\n  orizu tasks create --project <team/project> --dataset <datasetId> --app <appId> --title <title> --assignees <userId1,userId2> [--instructions <text>] [--labels-per-item <n>]\n  orizu tasks assign --task <taskId> --assignees <userId1,userId2>\n  orizu tasks status --task <taskId> [--json]\n  orizu datasets upload --file <path> [--project <team/project>] [--name <name>]\n  orizu datasets download [--dataset <datasetId|datasetUrl>] [--project <team/project>] [--format <csv|json|jsonl>] [--out <path>]\n  orizu datasets append [--dataset <datasetId|datasetUrl>] [--project <team/project>] --file <path>\n  orizu datasets edit-rows [--dataset <datasetId|datasetUrl>] [--project <team/project>] --file <path>\n  orizu datasets delete-rows [--dataset <datasetId|datasetUrl>] [--project <team/project>] --row-ids <id1,id2>\n  orizu datasets lock [--dataset <datasetId|datasetUrl>] [--project <team/project>] [--reason <text>]\n  orizu datasets clone [--dataset <datasetId|datasetUrl>] [--project <team/project>] [--name <name>]\n  orizu tasks export [--task <taskId>] [--format <csv|json|jsonl>] [--out <path>]`);
+    console.log(`orizu global options:\n\n  --local                 Use http://localhost:3000\n  --server <url>          Use a specific server origin (for example: https://preview.example.com)\n\norizu commands:\n\n  orizu login\n  orizu logout\n  orizu whoami\n  orizu teams list\n  orizu teams create [--name <name>]\n  orizu teams members list [--team <teamSlug>]\n  orizu teams members add --email <email> [--team <teamSlug>]\n  orizu teams members remove --email <email> [--team <teamSlug>]\n  orizu teams members role --team <teamSlug> --email <email> --role <admin|member>\n  orizu projects list [--team <teamSlug>]\n  orizu projects create --name <name> [--team <teamSlug>]\n  orizu apps list [--project <team/project>]\n  orizu apps create --project <team/project> --name <name> --dataset <datasetId> --file <path> --input-schema <json-path> --output-schema <json-path> [--component <name>]\n  orizu apps update [--app <appId>] [--project <team/project>] --file <path> --input-schema <json-path> --output-schema <json-path> [--component <name>]\n  orizu apps link-dataset --dataset <datasetId> [--app <appId>] [--project <team/project>] [--version <n>]\n  orizu apps detail --app <appId> [--project <team/project>] [--json]\n  orizu tasks list [--project <team/project>]\n  orizu tasks create --project <team/project> --dataset <datasetId> --app <appId> --title <title> --assignees <userIdOrEmail1,userIdOrEmail2> [--version <n>] [--instructions <text>] [--labels-per-item <n>] [--json]\n  orizu tasks assign --task <taskId> --assignees <userId1,userId2>\n  orizu tasks status --task <taskId> [--json]\n  orizu tasks pause --task <taskId>\n  orizu tasks unpause --task <taskId>\n  orizu datasets upload --file <path> [--project <team/project>] [--name <name>]\n  orizu datasets download [--dataset <datasetId|datasetUrl>] [--project <team/project>] [--format <csv|json|jsonl>] [--out <path>]\n  orizu datasets append [--dataset <datasetId|datasetUrl>] [--project <team/project>] --file <path>\n  orizu datasets edit-rows [--dataset <datasetId|datasetUrl>] [--project <team/project>] --file <path>\n  orizu datasets delete-rows [--dataset <datasetId|datasetUrl>] [--project <team/project>] --row-ids <id1,id2>\n  orizu datasets lock [--dataset <datasetId|datasetUrl>] [--project <team/project>] [--reason <text>]\n  orizu datasets clone [--dataset <datasetId|datasetUrl>] [--project <team/project>] [--name <name>]\n  orizu tasks export [--task <taskId>] [--format <csv|json|jsonl>] [--out <path>]`);
 }
 let cliArgs = process.argv.slice(2);
 function getArg(name) {
@@ -313,16 +315,18 @@ function printTeamMembers(members) {
     }
     const rows = members.map(member => ({
         id: member.id,
+        userId: member.user_id || '-',
         email: member.email || '-',
         role: member.role || '-',
     }));
     const idWidth = Math.max('MEMBER ID'.length, ...rows.map(row => row.id.length));
+    const userIdWidth = Math.max('USER ID'.length, ...rows.map(row => row.userId.length));
     const emailWidth = Math.max('EMAIL'.length, ...rows.map(row => row.email.length));
     const roleWidth = Math.max('ROLE'.length, ...rows.map(row => row.role.length));
-    console.log(`${'MEMBER ID'.padEnd(idWidth)}  ${'EMAIL'.padEnd(emailWidth)}  ${'ROLE'.padEnd(roleWidth)}`);
-    console.log(`${'-'.repeat(idWidth)}  ${'-'.repeat(emailWidth)}  ${'-'.repeat(roleWidth)}`);
+    console.log(`${'MEMBER ID'.padEnd(idWidth)}  ${'USER ID'.padEnd(userIdWidth)}  ${'EMAIL'.padEnd(emailWidth)}  ${'ROLE'.padEnd(roleWidth)}`);
+    console.log(`${'-'.repeat(idWidth)}  ${'-'.repeat(userIdWidth)}  ${'-'.repeat(emailWidth)}  ${'-'.repeat(roleWidth)}`);
     rows.forEach(row => {
-        console.log(`${row.id.padEnd(idWidth)}  ${row.email.padEnd(emailWidth)}  ${row.role.padEnd(roleWidth)}`);
+        console.log(`${row.id.padEnd(idWidth)}  ${row.userId.padEnd(userIdWidth)}  ${row.email.padEnd(emailWidth)}  ${row.role.padEnd(roleWidth)}`);
     });
 }
 function printTaskStatusSummary(data) {
@@ -340,14 +344,27 @@ function printTaskStatusSummary(data) {
         });
     }
 }
+const DEFAULT_AUTH_CALLBACK_PORT = 43123;
+function resolveAuthCallbackPort() {
+    const envPort = process.env.ORIZU_AUTH_PORT;
+    if (!envPort) {
+        return DEFAULT_AUTH_CALLBACK_PORT;
+    }
+    const parsed = parseInt(envPort, 10);
+    if (Number.isNaN(parsed) || parsed < 1024 || parsed > 65535) {
+        throw new Error(`Invalid ORIZU_AUTH_PORT: '${envPort}'. Must be a number between 1024 and 65535.`);
+    }
+    return parsed;
+}
 async function login() {
     const baseUrl = resolveLoginBaseUrl();
     const codeVerifier = createCodeVerifier();
     const codeChallenge = createCodeChallenge(codeVerifier);
+    const callbackPort = resolveAuthCallbackPort();
     const callbackCode = await new Promise((resolve, reject) => {
         const server = createServer((request, response) => {
             try {
-                const url = new URL(request.url || '/', 'http://127.0.0.1:43123');
+                const url = new URL(request.url || '/', `http://127.0.0.1:${callbackPort}`);
                 const code = url.searchParams.get('code');
                 if (!code) {
                     response.statusCode = 400;
@@ -365,10 +382,17 @@ async function login() {
                 reject(error);
             }
         });
-        server.on('error', reject);
-        server.listen(43123, '127.0.0.1', async () => {
+        server.on('error', (error) => {
+            if (error.code === 'EADDRINUSE') {
+                reject(new Error(`Port ${callbackPort} is already in use. Set ORIZU_AUTH_PORT to a different port (1024–65535) and retry.`));
+            }
+            else {
+                reject(error);
+            }
+        });
+        server.listen(callbackPort, '127.0.0.1', async () => {
             try {
-                const redirectUri = 'http://127.0.0.1:43123/callback';
+                const redirectUri = `http://127.0.0.1:${callbackPort}/callback`;
                 const response = await fetch(`${baseUrl}/api/cli/auth/start`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
@@ -601,10 +625,14 @@ async function linkAppDataset() {
     const project = getArg('--project');
     let appId = getArg('--app');
     const versionArg = getArg('--version');
-    const versionNum = versionArg ? Number(versionArg) : undefined;
+    const parsedVersionNum = versionArg ? Number(versionArg) : Number.NaN;
+    const versionNum = Number.isInteger(parsedVersionNum) && parsedVersionNum > 0 ? parsedVersionNum : undefined;
     if (!datasetId) {
         throw new Error('Usage: orizu apps link-dataset --dataset <datasetId> [--app <appId>] [--project <team/project>] [--version <n>]');
     }
+    if (versionArg && versionNum === undefined) {
+        throw new Error('--version must be a positive integer');
+    }
     if (!appId) {
         const selected = await selectAppIdInteractively(project);
         appId = selected.appId;
@@ -638,11 +666,17 @@ async function createTask() {
     const appId = getArg('--app');
     const title = getArg('--title');
     const assignees = parseCommaSeparated(getArg('--assignees'));
+    const versionArg = getArg('--version');
     const instructions = getArg('--instructions');
     const labelsPerItemArg = getArg('--labels-per-item');
     const labelsPerItem = labelsPerItemArg ? Number(labelsPerItemArg) : 1;
+    const parsedVersionNum = versionArg ? Number(versionArg) : Number.NaN;
+    const versionNum = Number.isInteger(parsedVersionNum) && parsedVersionNum > 0 ? parsedVersionNum : null;
     if (!projectSlug || !datasetId || !appId || !title || assignees.length === 0) {
-        throw new Error('Usage: orizu tasks create --project <team/project> --dataset <datasetId> --app <appId> --title <title> --assignees <userId1,userId2> [--instructions <text>] [--labels-per-item <n>]');
+        throw new Error('Usage: orizu tasks create --project <team/project> --dataset <datasetId> --app <appId> --title <title> --assignees <userIdOrEmail1,userIdOrEmail2> [--version <n>] [--instructions <text>] [--labels-per-item <n>] [--json]');
+    }
+    if (versionArg && versionNum === null) {
+        throw new Error('--version must be a positive integer');
     }
     const response = await authedFetch('/api/cli/tasks', {
         method: 'POST',
@@ -651,6 +685,7 @@ async function createTask() {
             projectSlug,
             datasetId,
             appId,
+            versionNum,
             title,
             memberIds: assignees,
             instructions,
@@ -658,10 +693,43 @@ async function createTask() {
         }),
     });
     if (!response.ok) {
-        throw new Error(`Failed to create task: ${await response.text()}`);
+        const cliError = await formatTaskCreateError(response);
+        if (hasArg('--json')) {
+            const payload = cliError.structuredPayload ?? { error: cliError.message };
+            console.log(JSON.stringify({
+                ...payload,
+                httpStatus: cliError.httpStatus,
+            }, null, 2));
+        }
+        throw cliError;
     }
     const data = await parseJsonResponse(response, 'Task create');
-    console.log(`Created task ${data.task.title} (${data.task.id}) [${data.task.status}], labels/item=${data.task.requiredAssignmentsPerRow}, assignments=${data.assignmentsCreated}`);
+    if (hasArg('--json')) {
+        console.log(JSON.stringify({
+            taskId: data.task.id,
+            datasetId,
+            versionId: data.task.versionId,
+            versionNum: data.task.versionNum,
+            taskUrl: `${getBaseUrl()}/d/${projectSlug}/tasks/${data.task.id}`,
+            title: data.task.title,
+            status: data.task.status,
+            requiredAssignmentsPerRow: data.task.requiredAssignmentsPerRow,
+            assignmentsCreated: data.assignmentsCreated,
+            ...(data.assignmentShortfall !== undefined ? { assignmentShortfall: data.assignmentShortfall } : {}),
+            ...(data.warning ? { warning: data.warning } : {}),
+        }, null, 2));
+        return;
+    }
+    const baseUrl = getBaseUrl();
+    const taskUrl = `${baseUrl}/d/${projectSlug}/tasks/${data.task.id}`;
+    console.log(`Created task ${data.task.title} (${data.task.id}) [${data.task.status}]` +
+        `\n  Task ID:    ${data.task.id}` +
+        `\n  Dataset ID: ${datasetId}` +
+        `\n  Version:    v${data.task.versionNum} (${data.task.versionId})` +
+        `\n  Labels/row: ${data.task.requiredAssignmentsPerRow}` +
+        `\n  Assignments: ${data.assignmentsCreated}` +
+        (data.warning ? `\n  Warning:    ${data.warning}` : '') +
+        `\n  URL:        ${taskUrl}`);
 }
 async function assignTask() {
     const taskId = getArg('--task');
@@ -687,7 +755,32 @@ async function taskStatus() {
     }
     const response = await authedFetch(`/api/cli/tasks/${encodeURIComponent(taskId)}/status`);
     if (!response.ok) {
-        throw new Error(`Failed to fetch task status: ${await response.text()}`);
+        const rawBody = await response.text();
+        if (hasArg('--json')) {
+            let errorPayload = { error: rawBody };
+            try {
+                const parsed = JSON.parse(rawBody);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    errorPayload = parsed;
+                }
+            }
+            catch {
+                // keep raw body as error
+            }
+            console.log(JSON.stringify({
+                ...errorPayload,
+                httpStatus: response.status,
+            }, null, 2));
+        }
+        let errorMsg = rawBody;
+        try {
+            const parsed = JSON.parse(rawBody);
+            if (parsed && typeof parsed === 'object' && typeof parsed.error === 'string') {
+                errorMsg = parsed.error;
+            }
+        }
+        catch { /* use rawBody as-is */ }
+        throw new Error(`Failed to fetch task status: ${errorMsg}`);
     }
     const data = await parseJsonResponse(response, 'Task status');
     if (hasArg('--json')) {
@@ -696,6 +789,63 @@ async function taskStatus() {
     }
     printTaskStatusSummary(data);
 }
+async function updateTaskStatus(targetStatus) {
+    const taskId = getArg('--task');
+    if (!taskId) {
+        const verb = targetStatus === 'paused' ? 'pause' : 'unpause';
+        throw new Error(`Usage: orizu tasks ${verb} --task <taskId>`);
+    }
+    const response = await authedFetch(`/api/cli/tasks/${encodeURIComponent(taskId)}/status`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ status: targetStatus }),
+    });
+    if (!response.ok) {
+        const verb = targetStatus === 'paused' ? 'pause' : 'unpause';
+        throw new Error(`Failed to ${verb} task: ${await response.text()}`);
+    }
+    const data = await parseJsonResponse(response, 'Task status update');
+    const action = targetStatus === 'paused' ? 'Paused' : 'Unpaused';
+    console.log(`${action} task ${data.task.id} [${data.task.status}]`);
+}
+async function appDetail() {
+    const appId = getArg('--app');
+    const project = getArg('--project');
+    if (!appId) {
+        throw new Error('Usage: orizu apps detail --app <appId> [--project <team/project>] [--json]');
+    }
+    const projectSlug = project || await resolveProjectSlug(null);
+    // Single fetch — the apps endpoint already returns full detail (ALI-544)
+    const detailResponse = await authedFetch(`/api/cli/apps?project=${encodeURIComponent(projectSlug)}`);
+    if (!detailResponse.ok) {
+        throw new Error(`Failed to fetch app detail: ${await detailResponse.text()}`);
+    }
+    const detailData = await parseJsonResponse(detailResponse, 'App detail');
+    const detail = detailData.apps.find(a => a.id === appId);
+    if (!detail) {
+        throw new Error(`App '${appId}' not found in project '${projectSlug}'`);
+    }
+    if (hasArg('--json')) {
+        console.log(JSON.stringify(detail, null, 2));
+        return;
+    }
+    console.log(`App: ${detail.name} (${detail.id})`);
+    console.log(`  Project: ${detail.teamSlug}/${detail.projectSlug}`);
+    if (detail.currentVersion) {
+        console.log(`  Current version: v${detail.currentVersion.versionNum} (${detail.currentVersion.versionId})`);
+        console.log(`  Input schema: ${detail.currentVersion.inputJsonSchema ? 'defined' : 'none'}`);
+        console.log(`  Output schema: ${detail.currentVersion.outputJsonSchema ? 'defined' : 'none'}`);
+    }
+    else {
+        console.log(`  Current version: none`);
+    }
+    console.log(`  Compatible datasets: ${detail.compatibleDatasetsCount}/${detail.totalDatasetsCount}`);
+    if (detail.createdByEmail) {
+        console.log(`  Created by: ${detail.createdByName || detail.createdByEmail}`);
+    }
+    console.log(`  Created: ${detail.createdAt}`);
+    console.log(`  Updated: ${detail.updatedAt}`);
+}
 async function listTeamMembers() {
     const teamSlug = await resolveTeamSlug(getArg('--team'));
     printTeamMembers(await fetchTeamMembers(teamSlug));
@@ -759,17 +909,7 @@ async function changeTeamMemberRole() {
     }
     console.log(`Updated ${member.email} role to ${role}`);
 }
-async function uploadDataset() {
-    const projectArg = getArg('--project');
-    const fileArg = getArg('--file');
-    const name = getArg('--name');
-    if (!fileArg) {
-        throw new Error('Usage: orizu datasets upload --file <path> [--project <team/project>] [--name <name>]');
-    }
-    const file = expandHomePath(fileArg);
-    const project = await resolveProjectSlug(projectArg);
-    const { rows, sourceType } = parseDatasetFile(file);
-    const datasetName = name || basename(file);
+async function createDatasetFromRows(project, name, sourceType, rows) {
     const response = await authedFetch('/api/cli/datasets/upload', {
         method: 'POST',
         headers: {
@@ -777,7 +917,7 @@ async function uploadDataset() {
         },
         body: JSON.stringify({
             projectSlug: project,
-            name: datasetName,
+            name,
             rows,
             sourceType,
         }),
@@ -786,7 +926,83 @@ async function uploadDataset() {
         const body = await parseJsonResponse(response, 'Dataset upload');
         throw new Error(`Upload failed: ${body.error}`);
     }
-    const data = await parseJsonResponse(response, 'Dataset upload');
+    return parseJsonResponse(response, 'Dataset upload');
+}
+async function uploadJsonlDatasetInChunks(file, project, datasetName) {
+    let dataset = null;
+    let totalUploaded = 0;
+    let chunkIndex = 0;
+    const chunks = streamJsonlRowChunks(file)[Symbol.asyncIterator]();
+    while (true) {
+        let nextChunk;
+        try {
+            nextChunk = await chunks.next();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!dataset) {
+                throw new Error(message);
+            }
+            throw new Error(`Upload stopped while reading the next JSONL chunk: ${message}\n` +
+                `Dataset ${dataset.name} (${dataset.id}) was created and ${totalUploaded} rows were uploaded. ` +
+                `Fix the file, remove the first ${totalUploaded} rows, and run ` +
+                `orizu datasets append --dataset ${dataset.id} --file <remaining-file>.`);
+        }
+        if (nextChunk.done) {
+            break;
+        }
+        const chunk = nextChunk.value;
+        chunkIndex += 1;
+        console.log(`Uploading chunk ${chunkIndex} (${chunk.length} rows)...`);
+        try {
+            if (!dataset) {
+                const data = await createDatasetFromRows(project, datasetName, 'jsonl', chunk);
+                dataset = data.dataset;
+                totalUploaded = data.dataset.rowCount;
+                continue;
+            }
+            const data = await appendChunk(dataset.id, chunk);
+            totalUploaded += data.appendedCount;
+            dataset = {
+                ...dataset,
+                rowCount: data.dataset.rowCount,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!dataset) {
+                throw new Error(message);
+            }
+            throw new Error(`Chunk ${chunkIndex} failed: ${message}\n` +
+                `Dataset ${dataset.name} (${dataset.id}) was created and ${totalUploaded} rows were uploaded. ` +
+                `To retry, remove the first ${totalUploaded} rows from your file and run ` +
+                `orizu datasets append --dataset ${dataset.id} --file <remaining-file>.`);
+        }
+    }
+    if (!dataset) {
+        throw new Error('Dataset file contains no rows');
+    }
+    console.log(`Uploaded dataset ${dataset.name} (${dataset.id}) with ${dataset.rowCount} rows.`);
+    if (dataset.url) {
+        console.log(`View dataset: ${formatTerminalLink(dataset.url)}`);
+    }
+}
+async function uploadDataset() {
+    const projectArg = getArg('--project');
+    const fileArg = getArg('--file');
+    const name = getArg('--name');
+    if (!fileArg) {
+        throw new Error('Usage: orizu datasets upload --file <path> [--project <team/project>] [--name <name>]');
+    }
+    const file = expandHomePath(fileArg);
+    const project = await resolveProjectSlug(projectArg);
+    const datasetName = name || basename(file);
+    if (extname(file).toLowerCase() === '.jsonl') {
+        await uploadJsonlDatasetInChunks(file, project, datasetName);
+        return;
+    }
+    const { rows, sourceType } = parseDatasetFile(file);
+    const data = await createDatasetFromRows(project, datasetName, sourceType, rows);
     console.log(`Uploaded dataset ${data.dataset.name} (${data.dataset.id}) with ${data.dataset.rowCount} rows.`);
     if (data.dataset.url) {
         console.log(`View dataset: ${formatTerminalLink(data.dataset.url)}`);
@@ -830,6 +1046,58 @@ async function downloadDataset() {
     writeFileSync(filename, bytes);
     console.log(`Saved dataset ${datasetId} (${format.toUpperCase()}) to ${filename}`);
 }
+const MAX_INPUT_FILE_SIZE_BYTES = 50 * 1024 * 1024; // 50 MB
+const APPEND_CHUNK_SIZE_ROWS = 500;
+async function appendChunk(datasetId, rows) {
+    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/rows`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ rows }),
+    });
+    if (!response.ok) {
+        throw new Error(`Append failed: ${await response.text()}`);
+    }
+    return parseJsonResponse(response, 'Dataset append');
+}
+async function appendJsonlDatasetRowsInChunks(datasetId, file) {
+    let totalAppended = 0;
+    let lastResult = null;
+    let chunkIndex = 0;
+    const chunks = streamJsonlRowChunks(file)[Symbol.asyncIterator]();
+    while (true) {
+        let nextChunk;
+        try {
+            nextChunk = await chunks.next();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Append stopped while reading the next JSONL chunk: ${message}\n` +
+                `${totalAppended} rows from ${chunkIndex} chunk(s) were already appended. ` +
+                `Fix the file, remove the first ${totalAppended} rows, and re-run the command.`);
+        }
+        if (nextChunk.done) {
+            break;
+        }
+        const chunk = nextChunk.value;
+        chunkIndex += 1;
+        console.log(`Uploading chunk ${chunkIndex} (${chunk.length} rows)...`);
+        try {
+            const data = await appendChunk(datasetId, chunk);
+            totalAppended += data.appendedCount;
+            lastResult = data;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Chunk ${chunkIndex} failed: ${message}\n` +
+                `${totalAppended} rows from ${chunkIndex - 1} chunk(s) were already appended. ` +
+                `To retry, remove the first ${totalAppended} rows from your file and re-run the command.`);
+        }
+    }
+    if (!lastResult) {
+        throw new Error('Dataset append file must contain at least one row');
+    }
+    console.log(`Appended ${totalAppended} rows to dataset ${lastResult.dataset.name} (${lastResult.dataset.id}). New row count: ${lastResult.dataset.rowCount}`);
+}
 async function appendDatasetRows() {
     const projectArg = getArg('--project');
     const datasetInput = getDatasetReferenceInput();
@@ -846,20 +1114,63 @@ async function appendDatasetRows() {
         datasetId = selected.datasetId;
     }
     const file = expandHomePath(fileArg);
+    if (extname(file).toLowerCase() === '.jsonl') {
+        await appendJsonlDatasetRowsInChunks(datasetId, file);
+        return;
+    }
+    // Check file size before reading to prevent OOM on large files (ALI-565).
+    // Wrap statSync in try/catch so missing/inaccessible files get friendly
+    // errors instead of raw Node.js ENOENT/EPERM (ALI-554).
+    let fileSizeBytes;
+    try {
+        fileSizeBytes = statSync(file).size;
+    }
+    catch (error) {
+        const maybeError = error;
+        if (maybeError.code === 'ENOENT') {
+            throw new Error(`File not found: ${file}. Check the path and filename, then retry.`);
+        }
+        if (maybeError.code === 'EPERM' || maybeError.code === 'EACCES') {
+            throw new Error(`Cannot read file: ${file}. Grant folder permission to your terminal app and retry.`);
+        }
+        throw new Error(`Failed to access file ${file}: ${maybeError.message}`);
+    }
+    if (fileSizeBytes > MAX_INPUT_FILE_SIZE_BYTES) {
+        const sizeMb = (fileSizeBytes / (1024 * 1024)).toFixed(1);
+        throw new Error(`Input file is ${sizeMb} MB, which exceeds the 50 MB limit. Split the file into smaller parts and append each separately.`);
+    }
     const { rows } = parseDatasetFile(file);
     if (!Array.isArray(rows) || rows.length === 0) {
         throw new Error('Dataset append file must contain at least one row');
     }
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/rows`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ rows }),
-    });
-    if (!response.ok) {
-        throw new Error(`Append failed: ${await response.text()}`);
+    if (rows.length <= APPEND_CHUNK_SIZE_ROWS) {
+        const data = await appendChunk(datasetId, rows);
+        console.log(`Appended ${data.appendedCount} rows to dataset ${data.dataset.name} (${data.dataset.id}). New row count: ${data.dataset.rowCount}`);
+        return;
+    }
+    // Chunked upload for large row counts (ALI-555: track partial progress)
+    let totalAppended = 0;
+    let lastResult = null;
+    const totalChunks = Math.ceil(rows.length / APPEND_CHUNK_SIZE_ROWS);
+    for (let offset = 0; offset < rows.length; offset += APPEND_CHUNK_SIZE_ROWS) {
+        const chunk = rows.slice(offset, offset + APPEND_CHUNK_SIZE_ROWS);
+        const chunkIndex = Math.floor(offset / APPEND_CHUNK_SIZE_ROWS) + 1;
+        console.log(`Uploading chunk ${chunkIndex}/${totalChunks} (${chunk.length} rows)...`);
+        try {
+            const data = await appendChunk(datasetId, chunk);
+            totalAppended += data.appendedCount;
+            lastResult = data;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Chunk ${chunkIndex}/${totalChunks} failed: ${msg}\n` +
+                `${totalAppended} rows from ${chunkIndex - 1} chunk(s) were already appended. ` +
+                `To retry, remove the first ${totalAppended} rows from your file and re-run the command.`);
+        }
+    }
+    if (lastResult) {
+        console.log(`Appended ${totalAppended} rows to dataset ${lastResult.dataset.name} (${lastResult.dataset.id}). New row count: ${lastResult.dataset.rowCount}`);
     }
-    const data = await parseJsonResponse(response, 'Dataset append');
-    console.log(`Appended ${data.appendedCount} rows to dataset ${data.dataset.name} (${data.dataset.id}). New row count: ${data.dataset.rowCount}`);
 }
 async function editDatasetRows() {
     const projectArg = getArg('--project');
@@ -1073,6 +1384,10 @@ async function main() {
         await linkAppDataset();
         return;
     }
+    if (command === 'apps' && subcommand === 'detail') {
+        await appDetail();
+        return;
+    }
     if (command === 'tasks' && subcommand === 'list') {
         await listTasks();
         return;
@@ -1089,6 +1404,14 @@ async function main() {
         await taskStatus();
         return;
     }
+    if (command === 'tasks' && subcommand === 'pause') {
+        await updateTaskStatus('paused');
+        return;
+    }
+    if (command === 'tasks' && subcommand === 'unpause') {
+        await updateTaskStatus('active');
+        return;
+    }
     if (command === 'datasets' && subcommand === 'upload') {
         await uploadDataset();
         return;