orizu 0.0.8 → 0.1.0

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

@@ -2,17 +2,19 @@
 import { createHash, randomBytes } from 'crypto';
 import { basename } 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 { parseDatasetReference } from './dataset-download.js';
+import { extractErrorMessage } from './error-response.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 delete-rows [--dataset <datasetId|datasetUrl>] [--project <team/project>] [--row-ids <id1,id2>] [--row-indices <n1,n2>]\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,44 @@ 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));
+            process.exit(1);
+        }
+        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 +756,25 @@ 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()}`);
+        if (hasArg('--json')) {
+            const rawBody = await response.text();
+            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));
+            process.exit(1);
+        }
+        throw new Error(`Failed to fetch task status: ${await extractErrorMessage(response)}`);
     }
     const data = await parseJsonResponse(response, 'Task status');
     if (hasArg('--json')) {
@@ -696,6 +783,68 @@ 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);
+    const apps = await fetchApps(projectSlug);
+    const app = apps.find(a => a.id === appId);
+    if (!app) {
+        throw new Error(`App '${appId}' not found in project '${projectSlug}'`);
+    }
+    // Re-fetch full detail from the list (it already returns full data)
+    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`);
+    }
+    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));
@@ -830,6 +979,19 @@ 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 appendDatasetRows() {
     const projectArg = getArg('--project');
     const datasetInput = getDatasetReferenceInput();
@@ -846,43 +1008,98 @@ async function appendDatasetRows() {
         datasetId = selected.datasetId;
     }
     const file = expandHomePath(fileArg);
+    // Parse the file first — parseDatasetFile provides user-friendly errors for
+    // ENOENT, EPERM, and EACCES. We check the file size afterward using the
+    // already-read content length to avoid a raw statSync ENOENT (ALI-554).
     const { rows } = parseDatasetFile(file);
     if (!Array.isArray(rows) || rows.length === 0) {
         throw new Error('Dataset append file must contain at least one row');
     }
+    const fileSizeBytes = statSync(file).size;
+    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.`);
+    }
+    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}`);
+    }
+}
+async function editDatasetRows() {
+    const projectArg = getArg('--project');
+    const datasetInput = getDatasetReferenceInput();
+    const fileArg = getArg('--file');
+    if (!fileArg) {
+        throw new Error('Usage: orizu datasets edit-rows [--dataset <datasetId|datasetUrl>] [--project <team/project>] --file <path>');
+    }
+    let datasetId;
+    if (datasetInput) {
+        datasetId = parseDatasetReference(datasetInput).datasetId;
+    }
+    else {
+        const selected = await selectDatasetInteractively(projectArg);
+        datasetId = selected.datasetId;
+    }
+    const file = expandHomePath(fileArg);
+    const { rows } = parseDatasetFile(file);
+    if (!Array.isArray(rows) || rows.length === 0) {
+        throw new Error('Dataset edit file must contain at least one row');
+    }
+    const normalizedRows = rows.map((row, index) => {
+        if (typeof row !== 'object' || row === null || Array.isArray(row)) {
+            throw new Error(`Dataset edit file rows[${index}] must be an object`);
+        }
+        const rowRecord = row;
+        const rowId = typeof rowRecord.id === 'string' ? rowRecord.id.trim() : '';
+        if (!rowId) {
+            throw new Error(`Dataset edit file rows[${index}] must include a non-empty string id`);
+        }
+        return {
+            ...rowRecord,
+            id: rowId,
+        };
+    });
     const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/rows`, {
-        method: 'POST',
+        method: 'PATCH',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ rows }),
+        body: JSON.stringify({ rows: normalizedRows }),
     });
     if (!response.ok) {
-        throw new Error(`Append failed: ${await response.text()}`);
-    }
-    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}`);
-}
-function parseCommaSeparatedIntegers(value) {
-    if (!value) {
-        return [];
+        throw new Error(`Edit rows failed: ${await response.text()}`);
     }
-    const rawItems = value
-        .split(',')
-        .map(item => item.trim())
-        .filter(Boolean);
-    const parsed = rawItems.map(item => Number(item));
-    const invalid = parsed.some(item => !Number.isInteger(item) || item < 0);
-    if (invalid) {
-        throw new Error('row-indices must be comma-separated non-negative integers');
-    }
-    return parsed;
+    const data = await parseJsonResponse(response, 'Dataset edit rows');
+    console.log(`Updated ${data.updatedCount} rows in dataset ${data.dataset.name} (${data.dataset.id}). Current row count: ${data.dataset.rowCount}`);
 }
 async function deleteDatasetRows() {
     const projectArg = getArg('--project');
     const datasetInput = getDatasetReferenceInput();
     const rowIds = parseCommaSeparated(getArg('--row-ids'));
-    const rowIndices = parseCommaSeparatedIntegers(getArg('--row-indices'));
-    if (rowIds.length === 0 && rowIndices.length === 0) {
-        throw new Error('Usage: orizu datasets delete-rows [--dataset <datasetId|datasetUrl>] [--project <team/project>] [--row-ids <id1,id2>] [--row-indices <n1,n2>]');
+    if (rowIds.length === 0) {
+        throw new Error('Usage: orizu datasets delete-rows [--dataset <datasetId|datasetUrl>] [--project <team/project>] --row-ids <id1,id2>');
     }
     let datasetId;
     if (datasetInput) {
@@ -897,7 +1114,6 @@ async function deleteDatasetRows() {
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
             rowIds,
-            rowIndices,
         }),
     });
     if (!response.ok) {
@@ -906,6 +1122,52 @@ async function deleteDatasetRows() {
     const data = await parseJsonResponse(response, 'Dataset delete rows');
     console.log(`Deleted ${data.deletedCount} rows from dataset ${data.dataset.name} (${data.dataset.id}). New row count: ${data.dataset.rowCount}`);
 }
+async function lockDataset() {
+    const projectArg = getArg('--project');
+    const datasetInput = getDatasetReferenceInput();
+    const reason = getArg('--reason');
+    let datasetId;
+    if (datasetInput) {
+        datasetId = parseDatasetReference(datasetInput).datasetId;
+    }
+    else {
+        const selected = await selectDatasetInteractively(projectArg);
+        datasetId = selected.datasetId;
+    }
+    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/lock`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(reason ? { reason } : {}),
+    });
+    if (!response.ok) {
+        throw new Error(`Lock failed: ${await response.text()}`);
+    }
+    const data = await parseJsonResponse(response, 'Dataset lock');
+    console.log(`Locked dataset ${data.dataset.name} (${data.dataset.id}) at ${data.dataset.lockedAt}. Row count: ${data.dataset.rowCount}`);
+}
+async function cloneDataset() {
+    const projectArg = getArg('--project');
+    const datasetInput = getDatasetReferenceInput();
+    const name = getArg('--name');
+    let datasetId;
+    if (datasetInput) {
+        datasetId = parseDatasetReference(datasetInput).datasetId;
+    }
+    else {
+        const selected = await selectDatasetInteractively(projectArg);
+        datasetId = selected.datasetId;
+    }
+    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/clone`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(name ? { name } : {}),
+    });
+    if (!response.ok) {
+        throw new Error(`Clone failed: ${await response.text()}`);
+    }
+    const data = await parseJsonResponse(response, 'Dataset clone');
+    console.log(`Cloned dataset ${data.dataset.parentDatasetId} -> ${data.dataset.name} (${data.dataset.id}). Row count: ${data.dataset.rowCount}`);
+}
 async function downloadAnnotations() {
     let taskId = getArg('--task');
     const format = (getArg('--format') || 'jsonl');
@@ -999,6 +1261,10 @@ async function main() {
         await linkAppDataset();
         return;
     }
+    if (command === 'apps' && subcommand === 'detail') {
+        await appDetail();
+        return;
+    }
     if (command === 'tasks' && subcommand === 'list') {
         await listTasks();
         return;
@@ -1015,6 +1281,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;
@@ -1027,10 +1301,22 @@ async function main() {
         await appendDatasetRows();
         return;
     }
+    if (command === 'datasets' && subcommand === 'edit-rows') {
+        await editDatasetRows();
+        return;
+    }
     if (command === 'datasets' && subcommand === 'delete-rows') {
         await deleteDatasetRows();
         return;
     }
+    if (command === 'datasets' && subcommand === 'lock') {
+        await lockDataset();
+        return;
+    }
+    if (command === 'datasets' && subcommand === 'clone') {
+        await cloneDataset();
+        return;
+    }
     if (command === 'tasks' && subcommand === 'export') {
         await downloadAnnotations();
         return;

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.8",
+  "version": "0.1.0",
   "private": false,
   "type": "module",
   "bin": {