@skrr-ai/cli 0.1.41 → 0.1.43

package/dist/lib/task-asset-upload.js

@@ -0,0 +1,374 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTaskForUpload = readTaskForUpload;
+exports.uploadTaskAssetFile = uploadTaskAssetFile;
+exports.attachTaskAssetFiles = attachTaskAssetFiles;
+exports.taskAssetMarkdownRef = taskAssetMarkdownRef;
+exports.sha256OfFile = sha256OfFile;
+exports.postFileToStorage = postFileToStorage;
+/**
+ * One Task-asset upload path for every CLI surface — `tasks attachments
+ * upload` and the `--attach` flag on updates/result/complete/comments all
+ * funnel here so the routing rules live in exactly one place (OSK-9863).
+ *
+ *   ≤25MB or image → buffered multipart (canonicalization needs the bytes)
+ *   larger non-image → intent → presigned POST to S3 → complete (OSK-9867)
+ *
+ * Session routing follows the CREDENTIAL, resolved here once per file so a
+ * narrowed agent session lands on `task-attachments*` and a human (or a
+ * delegated session holding a wide credential) lands on `/api/tasks/:id/*`.
+ *
+ * Retry safety is server-side: the sha256 IS the asset identity, so a second
+ * upload of the same bytes returns the existing ready row instead of
+ * duplicating it.
+ *
+ * The digest this module REPORTS is always the server's. The server
+ * canonicalizes images (EXIF strip, orientation, re-encode) before storing
+ * them, so the bytes on disk and the bytes stored are routinely different; an
+ * evidence reference that named the local hash would pin a version of the
+ * file that was never stored (OSK-10120). The local hash is computed only
+ * where the protocol needs it — declaring a direct upload, which storage then
+ * enforces — and never leaves this module as a claim about the asset.
+ */
+const fs = __importStar(require("node:fs"));
+const http = __importStar(require("node:http"));
+const https = __importStar(require("node:https"));
+const path = __importStar(require("node:path"));
+const node_buffer_1 = require("node:buffer");
+const node_crypto_1 = require("node:crypto");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../base-command");
+const file_mime_1 = require("./file-mime");
+const api_fetch_1 = require("./api-fetch");
+const session_task_endpoints_1 = require("./session-task-endpoints");
+function mb(bytes) {
+    return `${Math.floor(bytes / (1024 * 1024))} MB`;
+}
+const SHA256_HEX = /^[0-9a-f]{64}$/i;
+function storedDigest(asset) {
+    const value = asset.contentSha256;
+    return typeof value === 'string' && SHA256_HEX.test(value) ? value.toLowerCase() : undefined;
+}
+/**
+ * Read the Task an upload targets, through the same credential the upload
+ * will use. In a session the task comes from the claim, so the read is the
+ * bound task and `taskId` is only reconciled against it — a scoped credential
+ * refuses to act on any other task before a byte leaves the machine.
+ */
+async function readTaskForUpload(taskId) {
+    const readPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('read');
+    if (readPath) {
+        const bound = await (0, api_fetch_1.apiFetch)(readPath);
+        if (!(0, session_task_endpoints_1.requestMatchesBoundTask)(bound, taskId)) {
+            throw new Error(`This session is bound to task ${String(bound.identifier ?? bound.id ?? '?')} — a scoped credential cannot attach files to ${taskId}.`);
+        }
+        return bound;
+    }
+    return (await data_provider_1.dataService.getTask(taskId, { enrich: false }));
+}
+/**
+ * Upload `filePath` as a Task asset. In a session the task comes from the
+ * claim — `taskId` is only reconciled against the binding, never sent.
+ * Throws a plain Error; callers decide how to surface it.
+ */
+async function uploadTaskAssetFile(opts) {
+    const { taskId, filePath, role } = opts;
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) {
+        throw new Error(`Not a regular file: ${filePath}`);
+    }
+    const size = stat.size;
+    const filename = path.basename(filePath);
+    const mimeType = (0, file_mime_1.mimeTypeForFilename)(filename);
+    const isImage = mimeType.startsWith('image/');
+    if (isImage && size > data_provider_1.TASK_ATTACHMENT_MAX_BYTES) {
+        throw new Error(`${filename} is too large for an image (max ${mb(data_provider_1.TASK_ATTACHMENT_MAX_BYTES)})`);
+    }
+    if (size > data_provider_1.TASK_DIRECT_UPLOAD_MAX_BYTES) {
+        throw new Error(`${filename} exceeds the direct-upload limit (${mb(data_provider_1.TASK_DIRECT_UPLOAD_MAX_BYTES)})`);
+    }
+    const direct = !isImage && size > data_provider_1.TASK_ATTACHMENT_MAX_BYTES;
+    const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('attachment');
+    let result;
+    try {
+        if (sessionPath) {
+            await readTaskForUpload(taskId);
+            result = direct
+                ? await sessionDirectUpload({ filePath, size, filename, mimeType, role })
+                : await sessionBufferedUpload({ filePath, filename, mimeType, role });
+        }
+        else {
+            result = direct
+                ? await genericDirectUpload({ taskId, filePath, size, filename, mimeType, role })
+                : await genericBufferedUpload({ taskId, filePath, filename, mimeType, role });
+        }
+    }
+    catch (err) {
+        throw withServerReason(err, filename);
+    }
+    return {
+        id: String(result.id ?? result._id),
+        digest: storedDigest(result),
+        filename,
+        mimeType,
+        deduplicated: result.deduplicated === true,
+    };
+}
+/**
+ * Put the server's own reason on a refused upload.
+ *
+ * The transports keep response bodies out of `message` (a body can carry a
+ * stack trace), so a refusal read `HTTP 403 Forbidden — POST …` — and `--attach`
+ * prints only the message. Task media refusals are written to be acted on: 422
+ * an image whose bytes cannot be decoded, 415 a type the bytes contradict, 413
+ * the storage quota, 403 an agent asking for a Run input. The reason and its
+ * code replace the transport line; status and body stay on the error, so
+ * `handleApiError` still reads them. An error with no stated reason is left
+ * exactly as it was.
+ */
+function withServerReason(err, filename) {
+    if (!(err instanceof Error))
+        return err;
+    const { code, message } = (0, base_command_1.apiRefusal)(err);
+    if (!message)
+        return err;
+    err.message = `${filename}: ${message}${code ? ` (${code})` : ''}`;
+    return err;
+}
+/**
+ * Upload every `--attach` file and return the reference objects an Update or
+ * Result appends to `evidenceRefs`. Serial: half a dozen files is the
+ * realistic case and parallel uploads would race the session rate limiter.
+ */
+async function attachTaskAssetFiles(opts) {
+    const refs = [];
+    for (const filePath of opts.files) {
+        const asset = await uploadTaskAssetFile({
+            taskId: opts.taskId,
+            filePath,
+            role: opts.role,
+        });
+        refs.push({
+            kind: 'task_attachment',
+            id: asset.id,
+            ...(asset.digest ? { digest: `sha256:${asset.digest}` } : {}),
+        });
+    }
+    return refs;
+}
+/**
+ * The markdown image a comment body carries for an asset. The alt text is the
+ * filename, so its brackets are escaped: `shot [final].png` would otherwise
+ * close the alt early and break the reference.
+ */
+function taskAssetMarkdownRef(asset) {
+    const alt = asset.filename.replace(/[\\[\]]/g, (ch) => `\\${ch}`);
+    return `![${alt}](task-asset:${asset.id})`;
+}
+/**
+ * The buffered path holds the file in memory by design: it is capped at the
+ * buffered limit, and the server needs the whole body to canonicalize it.
+ */
+function fileFormData(filePath, filename, mimeType, role) {
+    const fd = new FormData();
+    fd.append('file', new node_buffer_1.Blob([fs.readFileSync(filePath)], { type: mimeType }), filename);
+    if (role)
+        fd.append('role', role);
+    return fd;
+}
+async function genericBufferedUpload(p) {
+    return data_provider_1.dataService.uploadTaskAttachment({
+        taskId: p.taskId,
+        formData: fileFormData(p.filePath, p.filename, p.mimeType, p.role),
+    });
+}
+async function sessionBufferedUpload(p) {
+    return (0, api_fetch_1.apiFetch)((await (0, session_task_endpoints_1.sessionScopedTaskPath)('attachment')), {
+        method: 'POST',
+        body: fileFormData(p.filePath, p.filename, p.mimeType, p.role),
+    });
+}
+async function genericDirectUpload(p) {
+    const intent = await data_provider_1.dataService.createTaskAttachmentUploadIntent({
+        taskId: p.taskId,
+        filename: p.filename,
+        mimeType: p.mimeType,
+        sizeBytes: p.size,
+        sha256: await sha256OfFile(p.filePath),
+        role: p.role,
+    });
+    if (!intent.uploadUrl)
+        return intent.attachment;
+    await postFileToStorage({
+        uploadUrl: intent.uploadUrl,
+        uploadFields: intent.uploadFields ?? {},
+        filePath: p.filePath,
+        size: p.size,
+        filename: p.filename,
+        mimeType: p.mimeType,
+    });
+    return data_provider_1.dataService.completeTaskAttachmentUpload({
+        taskId: p.taskId,
+        attachmentId: intent.attachment.id,
+    });
+}
+async function sessionDirectUpload(p) {
+    const intent = await (0, api_fetch_1.apiFetch)((await (0, session_task_endpoints_1.sessionScopedTaskPath)('attachmentIntent')), {
+        method: 'POST',
+        body: {
+            filename: p.filename,
+            mimeType: p.mimeType,
+            sizeBytes: p.size,
+            sha256: await sha256OfFile(p.filePath),
+            ...(p.role ? { role: p.role } : {}),
+        },
+    });
+    if (!intent.uploadUrl)
+        return intent.attachment;
+    await postFileToStorage({
+        uploadUrl: intent.uploadUrl,
+        uploadFields: intent.uploadFields ?? {},
+        filePath: p.filePath,
+        size: p.size,
+        filename: p.filename,
+        mimeType: p.mimeType,
+    });
+    return (0, api_fetch_1.apiFetch)((await (0, session_task_endpoints_1.sessionScopedTaskPath)('attachmentComplete')), {
+        method: 'POST',
+        body: { attachmentId: intent.attachment.id },
+    });
+}
+/** sha256 of a file, read as a stream: a 250MB recording never sits in memory. */
+async function sha256OfFile(filePath) {
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    for await (const chunk of fs.createReadStream(filePath)) {
+        hash.update(chunk);
+    }
+    return hash.digest('hex');
+}
+/** A form-data header value: no CR/LF, and quotes percent-encoded. */
+function quotedHeaderValue(value) {
+    return value.replace(/[\r\n]/g, ' ').replace(/"/g, '%22');
+}
+/**
+ * POST the file to the presigned URL as multipart/form-data, streamed from
+ * disk.
+ *
+ * Built by hand rather than with `FormData` + `fetch` for two reasons, both
+ * about large files. `FormData` needs a `Blob`, which here means the whole
+ * file in memory — the double buffering this replaced read up to 250MB and
+ * then copied it again. And storage refuses a POST without a Content-Length
+ * (it does not take chunked uploads), which a streamed `fetch` body cannot
+ * promise; the exact length is known here, because every part except the file
+ * is a small in-memory string and the file's size came from `stat`.
+ *
+ * `file` goes LAST — S3 presigned POST evaluates fields in order and ignores
+ * anything after it. The fields carry `x-amz-checksum-sha256`, so storage
+ * itself rejects bytes that do not match the digest the intent declared,
+ * including a file that changed between hashing and upload.
+ */
+async function postFileToStorage(p) {
+    const boundary = `----skrr-upload-${(0, node_crypto_1.randomBytes)(16).toString('hex')}`;
+    const fieldParts = Object.entries(p.uploadFields).map(([name, value]) => `--${boundary}\r\nContent-Disposition: form-data; name="${quotedHeaderValue(name)}"\r\n\r\n${value}\r\n`);
+    const head = Buffer.from(fieldParts.join('') +
+        `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${quotedHeaderValue(p.filename)}"\r\nContent-Type: ${quotedHeaderValue(p.mimeType)}\r\n\r\n`, 'utf8');
+    const tail = Buffer.from(`\r\n--${boundary}--\r\n`, 'utf8');
+    const url = new URL(p.uploadUrl);
+    const transport = url.protocol === 'http:' ? http : https;
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(err);
+        };
+        const req = transport.request(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Content-Length': String(head.length + p.size + tail.length),
+            },
+        }, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                if (body.length < 4096)
+                    body += chunk;
+            });
+            res.on('error', fail);
+            res.on('end', () => {
+                const status = res.statusCode ?? 0;
+                if (status >= 200 && status < 300) {
+                    if (!settled) {
+                        settled = true;
+                        resolve();
+                    }
+                    return;
+                }
+                // S3 names the refusal in XML (`<Code>BadDigest</Code>`,
+                // `EntityTooLarge`, `AccessDenied` once the POST policy expired).
+                // The code is the only part a person can act on.
+                const code = /<Code>([^<]+)<\/Code>/.exec(body)?.[1];
+                fail(new Error(`Storage rejected the upload (${status}${code ? ` ${code}` : ''})`));
+            });
+        });
+        req.on('error', fail);
+        req.write(head);
+        let sent = 0;
+        const stream = fs.createReadStream(p.filePath);
+        stream.on('data', (chunk) => {
+            sent += chunk.length;
+        });
+        stream.on('error', (err) => {
+            req.destroy(err);
+            fail(err);
+        });
+        stream.on('end', () => {
+            if (sent !== p.size) {
+                const err = new Error(`${p.filename} changed while it was being uploaded`);
+                req.destroy(err);
+                fail(err);
+                return;
+            }
+            req.end(tail);
+        });
+        stream.pipe(req, { end: false });
+    });
+}

package/dist/lib/task-closure.d.ts

@@ -1,4 +1,19 @@
 import type { TaskClosureEvaluation } from '@skrr-ai/data-provider';
+/**
+ * Is this Task SETTLED — closed in a way that refuses a new Result until it is
+ * reopened (`TASK_REOPEN_REQUIRED`)?
+ *
+ * Read the same way the server reads it: the immutable `statusType` when the row
+ * carries a known one, the legacy status id otherwise, and the `settled` band
+ * from the shared vocabulary rather than a column name. A command asks this
+ * BEFORE doing something the refusal would strand — uploading `--attach` files
+ * for a Result the server is about to refuse — and never instead of the
+ * server's own check, which stays the authority.
+ */
+export declare function taskIsSettled(task: {
+    statusType?: unknown;
+    status?: unknown;
+} | null | undefined): boolean;
 /**
  * Render "where does this Task actually stand" for every surface that should
  * say it.
@@ -28,6 +43,19 @@ export type ClosureLike = TaskClosureEvaluation | {
  * the whole point is to be able to act without a second lookup.
  */
 export declare function closureReport(closure: ClosureLike): string[];
+/**
+ * The ways forward when a closed Task refuses a Result (`TASK_REOPEN_REQUIRED`).
+ *
+ * Both writers reach this refusal, `tasks result submit` and `tasks complete`,
+ * so both print from here. The first version sat in `result submit` alone and
+ * offered `tasks complete` as a way around it, which the same refusal stops:
+ * every step named here has to work on a closed Task (OSK-10031).
+ */
+export declare function reopenRequiredLines({ bin, task, command, }: {
+    bin: string;
+    task: string;
+    command: 'result submit' | 'complete';
+}): string[];
 /** `met (agent)` vs `met (person)` — shared with the web through data-provider. */
 export { describeAssessorKind as describeAssessor } from '@skrr-ai/data-provider';
 export { describeClosure as closureSnapshotLines, type TaskClosureSnapshot as ClosureSnapshot, } from '@skrr-ai/data-provider';

package/dist/lib/task-closure.js

@@ -1,8 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.closureSnapshotLines = exports.describeAssessor = void 0;
+exports.taskIsSettled = taskIsSettled;
 exports.closureReport = closureReport;
+exports.reopenRequiredLines = reopenRequiredLines;
 const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * Is this Task SETTLED — closed in a way that refuses a new Result until it is
+ * reopened (`TASK_REOPEN_REQUIRED`)?
+ *
+ * Read the same way the server reads it: the immutable `statusType` when the row
+ * carries a known one, the legacy status id otherwise, and the `settled` band
+ * from the shared vocabulary rather than a column name. A command asks this
+ * BEFORE doing something the refusal would strand — uploading `--attach` files
+ * for a Result the server is about to refuse — and never instead of the
+ * server's own check, which stays the authority.
+ */
+function taskIsSettled(task) {
+    if (!task)
+        return false;
+    const type = (0, data_provider_1.isTaskWorkflowStateType)(task.statusType)
+        ? task.statusType
+        : data_provider_1.LEGACY_STATUS_TYPE_BY_ID[String(task.status ?? '')];
+    return Boolean(type) && data_provider_1.TASK_WORKFLOW_TYPE_BANDS.settled.includes(type);
+}
 function isUnavailable(closure) {
     return Boolean(closure && closure.unavailable);
 }
@@ -82,6 +103,22 @@ function closureReport(closure) {
         : 'Closing anyway is allowed — all of this is recorded on resolution.closure.');
     return lines;
 }
+/**
+ * The ways forward when a closed Task refuses a Result (`TASK_REOPEN_REQUIRED`).
+ *
+ * Both writers reach this refusal, `tasks result submit` and `tasks complete`,
+ * so both print from here. The first version sat in `result submit` alone and
+ * offered `tasks complete` as a way around it, which the same refusal stops:
+ * every step named here has to work on a closed Task (OSK-10031).
+ */
+function reopenRequiredLines({ bin, task, command, }) {
+    return [
+        `→ Reopen it: ${bin} tasks move ${task} --status in_progress`,
+        command === 'complete'
+            ? '→ Then run this command again.'
+            : `→ Then submit again, or submit and close in one step: ${bin} tasks complete ${task} --summary "…"`,
+    ];
+}
 /** `met (agent)` vs `met (person)` — shared with the web through data-provider. */
 var data_provider_2 = require("@skrr-ai/data-provider");
 Object.defineProperty(exports, "describeAssessor", { enumerable: true, get: function () { return data_provider_2.describeAssessorKind; } });

package/dist/lib/tasks.d.ts

@@ -1,4 +1,12 @@
 import type { ParsedDeliverableCoordinate, ParsedExpectationSpec } from '@skrr-ai/data-provider';
+/**
+ * `--goal` on `tasks update`. `none`, `null` and `clear` detach the goal: PATCH
+ * sends `goalId: null`. Anything else names a goal. `clear` is accepted because
+ * this same command documents it for `--expect`, so it is the spelling a user
+ * reaches for — and it used to be stored as a goal id (OSK-10207).
+ * Undefined means the flag was not passed.
+ */
+export declare function resolveTaskGoalFlag(value: string | undefined): string | null | undefined;
 export declare const TASK_PRIORITIES: readonly ["low", "medium", "high", "critical"];
 /**
  * The kinds `tasks events append --kind` will accept.

package/dist/lib/tasks.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RECOGNIZED_TASK_VERDICTS = exports.DELIVERABLE_LIFECYCLE_VALUES = exports.EXPECT_FLAG_HELP = exports.TASK_WORK_EVENT_KINDS = exports.TASK_PRIORITIES = void 0;
+exports.resolveTaskGoalFlag = resolveTaskGoalFlag;
 exports.releasePinRepairGuard = releasePinRepairGuard;
 exports.taskUpdateMutationGuard = taskUpdateMutationGuard;
 exports.executionIsolationFromWorktreeFlag = executionIsolationFromWorktreeFlag;
@@ -36,6 +37,21 @@ exports.verdictIsRecognized = verdictIsRecognized;
 const data_provider_1 = require("@skrr-ai/data-provider");
 const prompt_1 = require("./prompt");
 const projects_1 = require("./projects");
+/**
+ * `--goal` on `tasks update`. `none`, `null` and `clear` detach the goal: PATCH
+ * sends `goalId: null`. Anything else names a goal. `clear` is accepted because
+ * this same command documents it for `--expect`, so it is the spelling a user
+ * reaches for — and it used to be stored as a goal id (OSK-10207).
+ * Undefined means the flag was not passed.
+ */
+function resolveTaskGoalFlag(value) {
+    if (value === undefined)
+        return undefined;
+    const v = value.trim();
+    if (!v || ['none', 'null', 'clear'].includes(v.toLowerCase()))
+        return null;
+    return v;
+}
 exports.TASK_PRIORITIES = ['low', 'medium', 'high', 'critical'];
 const DESCRIPTION_FORMATS = ['html', 'markdown', 'plain'];
 /**