orizu 0.5.40 → 0.5.41

package/src/last-error-workflow.ts

@@ -0,0 +1,121 @@
+import { randomBytes } from 'crypto'
+import {
+  chmodSync,
+  closeSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'fs'
+import { join } from 'path'
+import { Effect, Schema } from 'effect'
+
+import {
+  LAST_ERROR_ARG_MAX_CHARS,
+  LAST_ERROR_CODE_MAX_CHARS,
+  LAST_ERROR_FILE_MAX_BYTES,
+  LAST_ERROR_MAX_ARGS,
+  LAST_ERROR_MESSAGE_MAX_CHARS,
+} from './last-error-caps.js'
+import {
+  boundedServerBaseUrl,
+  isStringWithinCap,
+  LAST_ERROR_FILENAME,
+  LAST_ERROR_RECORD_VERSION,
+  type LastErrorRecord,
+} from './last-error-record.js'
+
+// ORI-2450: Effect owns the last-error file's publication and reading.
+// last-error-record.ts loads this module with a literal dynamic import, so the
+// npm CLI only loads Effect on a failure or a feedback read, and the source
+// bundle still includes it.
+
+class LastErrorFileFailure extends Error {
+  constructor(readonly operation: string) {
+    super(`Could not ${operation}`)
+  }
+}
+
+const file = <A>(operation: string, action: () => A) => Effect.try({
+  try: action,
+  catch: () => new LastErrorFileFailure(operation),
+})
+
+const NullableString = Schema.NullOr(Schema.String)
+
+const LastErrorRecordSchema = Schema.Struct({
+  version: Schema.Literal(LAST_ERROR_RECORD_VERSION),
+  recordedAt: Schema.String.check(Schema.makeFilter(value => Number.isFinite(Date.parse(value)))),
+  cliVersion: NullableString,
+  code: Schema.optionalKey(NullableString.check(Schema.makeFilter(value =>
+    value === null || Array.from(value).length <= LAST_ERROR_CODE_MAX_CHARS))),
+  serverBaseUrl: Schema.optionalKey(NullableString),
+  teamSlug: Schema.optionalKey(NullableString),
+  command: NullableString,
+  argv: Schema.Array(Schema.String),
+  argvTruncated: Schema.Boolean,
+  message: Schema.String,
+  messageTruncated: Schema.Boolean,
+}).check(Schema.makeFilter(record =>
+  (record.command === null || isStringWithinCap(record.command, LAST_ERROR_ARG_MAX_CHARS, record.argvTruncated))
+  && record.argv.length <= LAST_ERROR_MAX_ARGS
+  && record.argv.every(argument => isStringWithinCap(argument, LAST_ERROR_ARG_MAX_CHARS, record.argvTruncated))
+  && isStringWithinCap(record.message, LAST_ERROR_MESSAGE_MAX_CHARS, record.messageTruncated)))
+
+const publication = (configDirectory: string, serialized: string) => Effect.gen(function*() {
+  yield* file('create directory', () => mkdirSync(configDirectory, { recursive: true, mode: 0o700 }))
+  yield* file('protect directory', () => chmodSync(configDirectory, 0o700))
+  const path = join(configDirectory, LAST_ERROR_FILENAME)
+  // Write a private temporary file, then rename it over the record, so a
+  // reader never sees a half-written record and a failed write keeps the old one.
+  yield* Effect.acquireUseRelease(
+    Effect.sync(() => join(
+      configDirectory,
+      `.${LAST_ERROR_FILENAME}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`
+    )),
+    temporaryPath => Effect.gen(function*() {
+      yield* Effect.acquireUseRelease(
+        file('open temporary record', () => openSync(temporaryPath, 'wx', 0o600)),
+        descriptor => Effect.gen(function*() {
+          yield* file('write temporary record', () => writeFileSync(descriptor, serialized, 'utf8'))
+          yield* file('flush temporary record', () => fsyncSync(descriptor))
+        }),
+        descriptor => Effect.sync(() => closeSync(descriptor)),
+      )
+      yield* file('protect temporary record', () => chmodSync(temporaryPath, 0o600))
+      yield* file('publish record', () => renameSync(temporaryPath, path))
+      yield* file('protect published record', () => chmodSync(path, 0o600))
+    }),
+    temporaryPath => Effect.sync(() => rmSync(temporaryPath, { force: true })),
+  )
+})
+
+export function publishLastErrorRecord(configDirectory: string, serialized: string): Promise<void> {
+  return Effect.runPromise(publication(configDirectory, serialized))
+}
+
+const loading = (path: string) => Effect.gen(function*() {
+  const stat = yield* file('inspect record', () => statSync(path))
+  if (stat.size > LAST_ERROR_FILE_MAX_BYTES) return null
+  const text = yield* file('read record', () => readFileSync(path, 'utf8'))
+  const raw = yield* file('parse record', () => JSON.parse(text) as unknown)
+  const record = yield* Schema.decodeUnknownEffect(LastErrorRecordSchema)(raw)
+  // The Schema checks the known fields; the reader has always kept any others.
+  const admitted: LastErrorRecord = {
+    ...(raw as Record<string, unknown>),
+    ...record,
+    argv: [...record.argv],
+    code: record.code ?? null,
+    serverBaseUrl: boundedServerBaseUrl(record.serverBaseUrl),
+    teamSlug: record.teamSlug ?? null,
+  }
+  return admitted
+})
+
+export function loadLastErrorRecord(path: string): Promise<LastErrorRecord | null> {
+  return Effect.runPromise(loading(path).pipe(Effect.orElseSucceed(() => null)))
+}

package/src/task-commands.ts

@@ -26,20 +26,6 @@ import type { TaskStatusPayload } from './account-directory.js'
 
 
 
-interface TaskReportPayload {
-  task: {
-    id: string
-    title?: string | null
-    status?: string | null
-    report: {
-      markdown: string
-      sourceName: string | null
-      createdAt: string | null
-      updatedAt?: string | null
-    }
-  }
-}
-
 function readTaskReportInput(): { markdown: string; sourceName: string | null } | null {
   return readMarkdownReportInput(cliArgs, 'Task')
 }
@@ -619,30 +605,14 @@ async function setTaskReport() {
     )
   }
 
-  const response = await authedFetch(`/api/cli/tasks/${encodeURIComponent(taskId)}/report`, {
-    method: 'PATCH',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      reportMarkdown: report.markdown,
-      reportSourceName: report.sourceName,
-    }),
-  })
-
-  if (!response.ok) {
-    throw new Error(`Failed to update task report: ${await response.text()}`)
+  // Loaded lazily: the workflow pulls in Effect (ORI-2408).
+  const workflow = await import('./task-report-workflow.js')
+  const outcome = await workflow.setTaskReport(taskId, report)
+  if (outcome.kind === 'interrupted') {
+    process.exitCode = outcome.exitCode
+    return
   }
-
-  const data = await parseJsonResponse<{
-    task: {
-      id: string
-      status: string
-      report: {
-        markdown: string
-        sourceName: string | null
-        createdAt: string | null
-      }
-    }
-  }>(response, 'Task report update')
+  const data = outcome.reply
 
   if (hasJsonFlag()) {
     printJson(data)
@@ -662,12 +632,8 @@ async function getTaskReport() {
     throw new Error('Usage: orizu tasks report get --task <taskId> [--json]')
   }
 
-  const response = await authedFetch(`/api/cli/tasks/${encodeURIComponent(taskId)}/report`)
-  if (!response.ok) {
-    throw new Error(`Failed to read task report: ${await response.text()}`)
-  }
-
-  const data = await parseJsonResponse<TaskReportPayload>(response, 'Task report get')
+  const workflow = await import('./task-report-workflow.js')
+  const data = await workflow.getTaskReport(taskId)
   if (hasJsonFlag()) {
     printJson(data as unknown as Record<string, unknown>)
     return

package/src/task-report-workflow.ts

@@ -0,0 +1,179 @@
+import { Cause, Effect, Exit, Result, Schema } from 'effect'
+
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js'
+import { isJsonErrorResponsePayload } from './error-response.js'
+import { authedFetch } from './http.js'
+import { parseJsonResponse } from './json-response.js'
+
+// Loaded only through `await import(...)` from task-commands. One request per
+// command, never retried, with the same deadline as the dataset workflows.
+
+const mayBeSaved = (taskId: string) =>
+  `The task report may already be saved: check with \`orizu tasks report get --task ${taskId}\` before setting it again.`
+
+const SetReply = Schema.Struct({
+  task: Schema.Struct({
+    id: Schema.String,
+    status: Schema.String,
+    report: Schema.Struct({
+      markdown: Schema.String,
+      sourceName: Schema.NullOr(Schema.String),
+      createdAt: Schema.NullOr(Schema.String),
+    }),
+  }),
+})
+
+// title, status and updatedAt stay optional, as in the payload type this replaced.
+const GetReply = Schema.Struct({
+  task: Schema.Struct({
+    id: Schema.String,
+    title: Schema.optionalKey(Schema.NullOr(Schema.String)),
+    status: Schema.optionalKey(Schema.NullOr(Schema.String)),
+    report: Schema.Struct({
+      markdown: Schema.String,
+      sourceName: Schema.NullOr(Schema.String),
+      createdAt: Schema.NullOr(Schema.String),
+      updatedAt: Schema.optionalKey(Schema.NullOr(Schema.String)),
+    }),
+  }),
+})
+
+type TaskReportSetReply = typeof SetReply.Type
+export type TaskReportGetReply = typeof GetReply.Type
+
+// `mayBeSaved` (the #2164 rule): an error reply in the app's own `{ error }`
+// shape is reported plainly, whatever its status. A lost, stalled or unreadable
+// reply, a 5xx that did not come from the app (a gateway giving up while the
+// app kept working), or a reply of the wrong shape means it may have been saved.
+class ReportRequestFailure extends Error {
+  constructor(message: string, readonly mayBeSaved: boolean, cause?: unknown) { super(message, { cause }) }
+}
+
+function isAppError(response: Response, text: string): boolean {
+  try {
+    return isJsonErrorResponsePayload(response, JSON.parse(text))
+  } catch {
+    return false
+  }
+}
+
+/** One request with a deadline. Returns the reply as parsed once `accepts` agrees with its shape. */
+function reportRequest(input: {
+  taskId: string
+  init: RequestInit
+  failurePrefix: string
+  label: string
+  accepts: (data: unknown) => boolean
+  deadlineMessage: string
+  timeoutMs: number
+  onSent?: () => void
+}) {
+  return Effect.suspend(() => {
+    let sent = false
+    let timedOut = false
+    return Effect.tryPromise({
+      try: async signal => {
+        const request = new AbortController()
+        const abort = () => request.abort()
+        const timer = setTimeout(() => { timedOut = true; request.abort() }, input.timeoutMs)
+        if (signal.aborted) abort()
+        else signal.addEventListener('abort', abort, { once: true })
+        try {
+          const response = await authedFetch(
+            `/api/cli/tasks/${encodeURIComponent(input.taskId)}/report`,
+            { ...input.init, signal: request.signal },
+            () => { sent = true; input.onSent?.() }
+          )
+          if (!response.ok) {
+            const text = await response.text()
+            const fromApp = isAppError(response, text)
+            throw new ReportRequestFailure(`${input.failurePrefix}: ${text}`, response.status < 400 || (response.status >= 500 && !fromApp))
+          }
+          const data = await parseJsonResponse<unknown>(response, input.label)
+          if (!input.accepts(data)) {
+            throw new ReportRequestFailure(`${input.label} returned an unexpected response (status ${response.status}).`, true)
+          }
+          return data
+        } finally {
+          clearTimeout(timer)
+          signal.removeEventListener('abort', abort)
+          request.abort()
+        }
+      },
+      catch: cause => {
+        if (timedOut) return new ReportRequestFailure(input.deadlineMessage, sent, cause)
+        if (cause instanceof ReportRequestFailure) return cause
+        return new ReportRequestFailure(cause instanceof Error ? cause.message : String(cause), sent, cause)
+      },
+    })
+  })
+}
+
+const accepts = (schema: typeof SetReply | typeof GetReply) => (data: unknown) => Result.isSuccess(Schema.decodeUnknownResult(schema)(data))
+
+export type TaskReportSetOutcome =
+  | { kind: 'saved'; reply: TaskReportSetReply }
+  | { kind: 'interrupted'; exitCode: 130 | 143 }
+
+/**
+ * `orizu tasks report set`. Ctrl-C or SIGTERM aborts the request and, once it
+ * was sent, says the report may already be saved: the server finishes on its
+ * own. Other failures throw, adding the same line when the outcome is unknown.
+ */
+export async function setTaskReport(taskId: string, report: { markdown: string; sourceName: string | null }): Promise<TaskReportSetOutcome> {
+  const timeoutMs = datasetTransferTimeoutMs()
+  const controller = new AbortController()
+  let interrupted: 130 | 143 | undefined
+  let sent = false
+  const interrupt = () => { interrupted ??= 130; controller.abort() }
+  const terminate = () => { interrupted ??= 143; controller.abort() }
+  process.on('SIGINT', interrupt)
+  process.on('SIGTERM', terminate)
+  try {
+    const exit = await Effect.runPromiseExit(reportRequest({
+      taskId,
+      init: {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ reportMarkdown: report.markdown, reportSourceName: report.sourceName }),
+      },
+      failurePrefix: 'Failed to update task report',
+      label: 'Task report update',
+      accepts: accepts(SetReply),
+      deadlineMessage: 'Task report save exceeded its deadline',
+      timeoutMs,
+      onSent: () => { sent = true },
+    }), { signal: controller.signal })
+    if (interrupted !== undefined) {
+      process.stderr.write(sent ? `Task report save interrupted. ${mayBeSaved(taskId)}\n` : 'Task report save interrupted.\n')
+      return { kind: 'interrupted', exitCode: interrupted }
+    }
+    if (Exit.isSuccess(exit)) return { kind: 'saved', reply: exit.value as TaskReportSetReply }
+    throw withMayBeSaved(Cause.squash(exit.cause), taskId)
+  } finally {
+    process.removeListener('SIGINT', interrupt)
+    process.removeListener('SIGTERM', terminate)
+  }
+}
+
+function withMayBeSaved(failure: unknown, taskId: string): unknown {
+  if (!(failure instanceof ReportRequestFailure)) return failure
+  const message = failure.mayBeSaved ? `${failure.message}\n${mayBeSaved(taskId)}` : failure.message
+  return new Error(message, { cause: failure.cause })
+}
+
+/** `orizu tasks report get`: one read with a deadline. Signals keep Node's default handling. */
+export async function getTaskReport(taskId: string): Promise<TaskReportGetReply> {
+  const exit = await Effect.runPromiseExit(reportRequest({
+    taskId,
+    init: {},
+    failurePrefix: 'Failed to read task report',
+    label: 'Task report get',
+    accepts: accepts(GetReply),
+    deadlineMessage: 'Task report read exceeded its deadline',
+    timeoutMs: datasetTransferTimeoutMs(),
+  }))
+  if (Exit.isSuccess(exit)) return exit.value as TaskReportGetReply
+  const failure = Cause.squash(exit.cause)
+  throw failure instanceof ReportRequestFailure ? new Error(failure.message, { cause: failure.cause }) : failure
+}