@mnstry/atelier 0.2.0-alpha.5 → 0.2.0-alpha.8

package/src/collaboration/inspection-bundle.mjs

@@ -0,0 +1,223 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  loadBoundRun,
+  hashEvidence,
+  validBoundRun,
+} from '../readiness-protocols/evidence.mjs'
+import { validReviewArtifact } from './review-contracts.mjs'
+import { createReviewStore, validContribution } from './review-store.mjs'
+import {
+  compileDisclosurePatterns,
+  scanDisclosureText,
+} from '../disclosure/content-scan.mjs'
+import { openRegularFileNoFollow } from '../project/private-state.mjs'
+
+function prohibitedKeys(value, depth = 0) {
+  if (
+    typeof value === 'string' &&
+    (/^(?:[A-Za-z]:[\\/]|\\\\|\/(?!\/))/.test(value) ||
+      /[a-z][a-z0-9+.-]*:\/\/[^/\s]*@/i.test(value))
+  )
+    throw new Error(
+      'machine path or credential-bearing URL in selected content',
+    )
+  if (depth > 32) throw new Error('bundle nesting exceeds bounds')
+  if (value && typeof value === 'object')
+    for (const [key, child] of Object.entries(value)) {
+      if (
+        /nonce|session|grant|credential|password|token|secret|private.?key|authorization/i.test(
+          key,
+        )
+      )
+        throw new Error('nontransferable field in selected content')
+      prohibitedKeys(child, depth + 1)
+    }
+}
+export function prepareInspectionBundle(
+  project,
+  runIds,
+  { denylistDocument, responseIds = [] } = {},
+) {
+  if (!denylistDocument || !Array.isArray(denylistDocument.patterns))
+    throw new Error('private disclosure policy required before export')
+  if (
+    !Array.isArray(runIds) ||
+    !runIds.length ||
+    runIds.length > 20 ||
+    new Set(runIds).size !== runIds.length
+  )
+    throw new Error('select 1 to 20 unique run IDs')
+  const history = createReviewStore(project).records()
+  if (!history.ok) throw new Error(history.error)
+  if (
+    !Array.isArray(responseIds) ||
+    responseIds.length > 2000 ||
+    new Set(responseIds).size !== responseIds.length
+  )
+    throw new Error('invalid response selection')
+  const responses = responseIds.map((id) => {
+    const record = history.records.find(
+      (entry) =>
+        entry.input.requestId === id && entry.input.kind !== 'decision',
+    )
+    if (!record) throw new Error('selected response unavailable')
+    return record
+  })
+  prohibitedKeys(responses)
+  const members = runIds.map((id) => {
+    const bound = loadBoundRun(project, id)
+    if (!bound.ok) throw new Error(bound.error)
+    const value = {
+      schema: bound.schema,
+      run: bound.run,
+      runDigest: bound.runDigest,
+      snapshot: bound.snapshot,
+      decisions: history.records.filter(
+        (record) =>
+          record.input.kind === 'decision' && record.input.runId === id,
+      ),
+    }
+    prohibitedKeys(value)
+    return {
+      id,
+      bytes: Buffer.byteLength(JSON.stringify(value)),
+      digest: hashEvidence(value),
+      value,
+    }
+  })
+  const body = {
+    schema: 'atelier-inspection-bundle@v1',
+    purpose: 'historical-inspection-only',
+    classification: 'owner-selected-private-review',
+    members,
+    responses,
+  }
+  const bytes = JSON.stringify(body, null, 2)
+  const disclosure = scanDisclosureText(bytes, {
+    denylistPatterns: compileDisclosurePatterns(denylistDocument.patterns),
+  })
+  if (!disclosure.ok)
+    throw new Error('selected content failed disclosure policy; export refused')
+  const bundle = { ...body, digest: hashEvidence(body) }
+  inspectBundle(bundle)
+  return bundle
+}
+export function inspectBundle(bundle) {
+  const serialized = JSON.stringify(bundle)
+  if (Buffer.byteLength(serialized) > 4 * 1024 * 1024)
+    throw new Error('bundle exceeds byte bound')
+  if (!validReviewArtifact('bundle', bundle))
+    throw new Error('inspection bundle contract invalid')
+  if (
+    !bundle ||
+    bundle.schema !== 'atelier-inspection-bundle@v1' ||
+    bundle.purpose !== 'historical-inspection-only' ||
+    !Array.isArray(bundle.members) ||
+    !bundle.members.length ||
+    bundle.members.length > 20 ||
+    Object.keys(bundle).some(
+      (key) =>
+        ![
+          'schema',
+          'purpose',
+          'classification',
+          'members',
+          'responses',
+          'digest',
+          'ext',
+          'contractVersion',
+        ].includes(key),
+    )
+  )
+    throw new Error('unsupported inspection bundle')
+  const { digest, ...body } = bundle
+  if (digest !== hashEvidence(body)) throw new Error('bundle digest mismatch')
+  const ids = new Set(),
+    requests = new Set()
+  const verifyRecord = (record) => {
+    if (!validContribution(record) || requests.has(record.input.requestId))
+      throw new Error('invalid or duplicate historical contribution')
+    requests.add(record.input.requestId)
+  }
+  prohibitedKeys(bundle.responses)
+  for (const record of bundle.responses) {
+    verifyRecord(record)
+    if (record.input.kind === 'decision')
+      throw new Error('decision outside run member')
+  }
+  for (const member of bundle.members) {
+    if (
+      !member ||
+      !/^readiness-run-[a-z0-9-]+$/.test(member.id ?? '') ||
+      ids.has(member.id) ||
+      Object.keys(member).some(
+        (key) => !['id', 'bytes', 'digest', 'value', 'ext'].includes(key),
+      ) ||
+      member.digest !== hashEvidence(member.value) ||
+      member.bytes !== Buffer.byteLength(JSON.stringify(member.value))
+    )
+      throw new Error('invalid, duplicate or changed bundle member')
+    prohibitedKeys(member.value)
+    ids.add(member.id)
+    const value = member.value,
+      { digest: snapshotDigest, ...snapshot } = value.snapshot ?? {}
+    const { decisions, ...bound } = value
+    if (
+      !validBoundRun(bound) ||
+      value.schema !== 'atelier-bound-run@v1' ||
+      value.run?.runId !== member.id ||
+      value.runDigest !== hashEvidence(value.run) ||
+      snapshotDigest !== hashEvidence(snapshot) ||
+      !Array.isArray(value.decisions)
+    )
+      throw new Error('invalid historical evidence')
+    for (const record of value.decisions) {
+      verifyRecord(record)
+      if (
+        record.input.kind !== 'decision' ||
+        record.input.runId !== member.id ||
+        record.input.evidenceDigest !== snapshotDigest ||
+        !value.run.claims.some(
+          (claim) => claim.claimId === record.input.targetId,
+        )
+      )
+        throw new Error('decision does not bind selected evidence')
+    }
+  }
+  return {
+    ok: true,
+    schema: 'atelier-inspection-report@v1',
+    approvalAuthority: false,
+    authorship: 'unverified-historical-assertions',
+    writes: false,
+    members: bundle.members,
+    responses: bundle.responses,
+  }
+}
+export function readInspectionBundle(file) {
+  const descriptor = openRegularFileNoFollow(file)
+  try {
+    if (fs.fstatSync(descriptor).size > 4 * 1024 * 1024)
+      throw new Error('bundle exceeds byte bound')
+    return inspectBundle(JSON.parse(fs.readFileSync(descriptor, 'utf8')))
+  } finally {
+    fs.closeSync(descriptor)
+  }
+}
+export function writeInspectionBundle(file, bundle) {
+  inspectBundle(bundle)
+  if (path.extname(file) !== '.json')
+    throw new Error('inspection bundle output must be a JSON file')
+  const descriptor = openRegularFileNoFollow(
+    file,
+    fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL,
+    0o600,
+  )
+  try {
+    fs.writeFileSync(descriptor, JSON.stringify(bundle, null, 2) + '\n')
+    fs.fsyncSync(descriptor)
+  } finally {
+    fs.closeSync(descriptor)
+  }
+}

package/src/collaboration/review-contracts.mjs

@@ -0,0 +1,25 @@
+import fs from 'node:fs'
+import Ajv2020 from 'ajv/dist/2020.js'
+import addFormats from 'ajv-formats'
+const ajv = new Ajv2020({ allErrors: true, strict: false })
+addFormats(ajv)
+for (const name of ['atelier-review'])
+  ajv.addSchema(
+    JSON.parse(
+      fs.readFileSync(
+        new URL(`../../contracts/${name}.v1.schema.json`, import.meta.url),
+        'utf8',
+      ),
+    ),
+  )
+const validators = new Map()
+export function validReviewArtifact(kind, value) {
+  if (!validators.has(kind))
+    validators.set(
+      kind,
+      ajv.compile({
+        $ref: `https://mnstry.ai/schemas/atelier/atelier-review.v1.schema.json#/$defs/${kind}`,
+      }),
+    )
+  return validators.get(kind)(value)
+}

package/src/collaboration/review-store.mjs

@@ -0,0 +1,305 @@
+import path from 'node:path'
+import { validReviewArtifact } from './review-contracts.mjs'
+import { createCollaborationEventLedger } from './event-ledger.mjs'
+import {
+  loadBoundRun,
+  currentRunEligibility,
+  hashEvidence,
+  readBoundedSource,
+} from '../readiness-protocols/evidence.mjs'
+import { buildGraph } from '../graph/graph.mjs'
+import { readRegularTextNoFollow } from '../project/private-state.mjs'
+
+const idPattern = /^[a-zA-Z0-9][a-zA-Z0-9:._-]{0,159}$/
+const text = (value, max) =>
+  typeof value === 'string' && value.trim().length > 0 && value.length <= max
+const invalid = (error, status = 400) => ({ ok: false, status, error })
+
+export const contributionKey = (input) =>
+  hashEvidence({
+    kind: input.kind,
+    targetId: input.targetId,
+    runId: input.runId ?? null,
+    repo: input.repo ?? null,
+    path: input.path ?? null,
+    reader: input.kind === 'position' ? input.reviewer : null,
+  })
+export function validContribution(record) {
+  return (
+    validReviewArtifact('record', record) &&
+    record.inputDigest === hashEvidence(record.input) &&
+    record.key === contributionKey(record.input) &&
+    record.version === record.input.expectedVersion + 1 &&
+    record.identity.name === record.input.reviewer
+  )
+}
+
+export function createReviewStore(project) {
+  const ledger = createCollaborationEventLedger({
+    workspaceRoot: project.configDir,
+    ledgerPath: path.join(
+      project.configDir,
+      '.atelier-local/review/contributions.ndjson',
+    ),
+  })
+  function records() {
+    const all = ledger.readAll()
+    if (!all.ok) return all
+    const result = all.events.map((event) => event.payload)
+    const versions = new Map(),
+      requests = new Set()
+    for (let index = 0; index < result.length; index++) {
+      const record = result[index],
+        event = all.events[index]
+      if (
+        !validContribution(record) ||
+        requests.has(record.input.requestId) ||
+        event.aggregateId !== `contribution:${record.input.requestId}` ||
+        event.type !== 'contribution-recorded' ||
+        event.actor !== record.input.reviewer ||
+        record.version !== (versions.get(record.key) ?? 0) + 1
+      )
+        return invalid('contribution history is invalid', 422)
+      requests.add(record.input.requestId)
+      versions.set(record.key, record.version)
+    }
+    return { ok: true, status: 200, records: result }
+  }
+  function contribution(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+      return invalid('contribution must be an object')
+    const keys = [
+      'requestId',
+      'kind',
+      'targetId',
+      'expectedVersion',
+      'reviewer',
+      'rationale',
+      'runId',
+      'evidenceDigest',
+      'decision',
+      'revision',
+      'repo',
+      'path',
+      'documentDigest',
+      'anchor',
+      'responseType',
+      'wording',
+      'position',
+      'ext',
+    ]
+    if (Object.keys(input).some((key) => !keys.includes(key)))
+      return invalid('unknown contribution field')
+    if (
+      !idPattern.test(input.requestId ?? '') ||
+      !idPattern.test(input.targetId ?? '') ||
+      !Number.isSafeInteger(input.expectedVersion) ||
+      input.expectedVersion < 0 ||
+      !text(input.reviewer, 160) ||
+      input.reviewer !== input.reviewer.trim()
+    )
+      return invalid(
+        'request identity, expected version and reviewer are required',
+      )
+    if (!['decision', 'response', 'position'].includes(input.kind))
+      return invalid('unsupported contribution kind')
+    if (
+      input.kind === 'decision' &&
+      (!['accepted', 'rejected', 'revised'].includes(input.decision) ||
+        !text(input.rationale, 8000) ||
+        !text(input.runId, 160) ||
+        !/^sha256:[a-f0-9]{64}$/.test(input.evidenceDigest ?? '') ||
+        (input.decision === 'revised' && !text(input.revision, 8000)))
+    )
+      return invalid('decision, rationale and evidence identity are required')
+    if (
+      input.kind !== 'decision' &&
+      (!text(input.repo, 160) ||
+        !text(input.path, 2048) ||
+        !/^sha256:[a-f0-9]{64}$/.test(input.documentDigest ?? '') ||
+        !text(input.anchor, 8000))
+    )
+      return invalid('document identity and passage anchor are required')
+    if (
+      input.kind === 'response' &&
+      (!['question', 'correction', 'discussion'].includes(input.responseType) ||
+        !text(input.wording, 16000))
+    )
+      return invalid('response type and original wording are required')
+    if (
+      input.kind === 'position' &&
+      (!Number.isSafeInteger(input.position) || input.position < 0)
+    )
+      return invalid('reading position is required')
+    if (!validReviewArtifact('input', input))
+      return invalid(
+        'contribution contract invalid or contains fields for a different kind',
+      )
+    const inputDigest = hashEvidence(input)
+    const history = records()
+    if (!history.ok) return history
+    const previous = history.records.find(
+      (record) => record.input.requestId === input.requestId,
+    )
+    if (previous)
+      return previous.inputDigest === inputDigest
+        ? { ok: true, status: 200, record: previous, replayed: true }
+        : invalid('request ID reused with different content', 409)
+    const key = contributionKey(input)
+    const payload = {
+      schema: 'atelier-contribution@v1',
+      input,
+      inputDigest,
+      key,
+      version: input.expectedVersion + 1,
+      identity: { kind: 'local-asserted', name: input.reviewer },
+      recordedAt: new Date().toISOString(),
+    }
+    const appended = ledger.append({
+      aggregateId: `contribution:${input.requestId}`,
+      expectedVersion: 0,
+      type: 'contribution-recorded',
+      actor: input.reviewer,
+      payload,
+      precondition: () => {
+        const current = records()
+        if (!current.ok) return current
+        const count = current.records.filter(
+          (record) => record.key === key,
+        ).length
+        if (count !== input.expectedVersion)
+          return invalid('stale contribution version', 409)
+        if (input.kind === 'decision') {
+          const bound = loadBoundRun(project, input.runId)
+          if (!bound.ok) return bound
+          if (
+            input.decision === 'accepted' &&
+            (bound.run.blockers.length ||
+              bound.snapshot.claimEvidence[
+                bound.run.claims.findIndex(
+                  (claim) => claim.claimId === input.targetId,
+                )
+              ]?.status !== 'linked-source')
+          )
+            return invalid(
+              'required input or mapped source evidence is incomplete; acceptance refused',
+              409,
+            )
+          if (
+            bound.snapshot.digest !== input.evidenceDigest ||
+            !bound.run.claims.some(
+              (claim) => claim.claimId === input.targetId,
+            ) ||
+            !currentRunEligibility(project, bound)
+          )
+            return invalid('claim evidence changed or is unavailable', 409)
+        } else {
+          const source = document(input.repo, input.path)
+          if (!source.ok) return source
+          if (
+            source.digest !== input.documentDigest ||
+            !source.text.includes(input.anchor)
+          )
+            return invalid(
+              'document changed or anchor is missing; reassociation required',
+              409,
+            )
+          if (
+            input.kind === 'position' &&
+            (input.position > source.text.length ||
+              !source.text.slice(input.position).startsWith(input.anchor))
+          )
+            return invalid('position does not match the anchored passage')
+        }
+        return { ok: true }
+      },
+    })
+    if (!appended.ok) {
+      if (appended.status === 409) {
+        const latest = records()
+        const duplicate =
+          latest.ok &&
+          latest.records.find(
+            (record) => record.input.requestId === input.requestId,
+          )
+        if (duplicate?.inputDigest === inputDigest)
+          return { ok: true, status: 200, record: duplicate, replayed: true }
+      }
+      return appended
+    }
+    return { ok: true, status: 200, record: payload, replayed: false }
+  }
+  function document(repoName, relative) {
+    const repo = project.repos.find(
+      (entry) => entry.name === repoName && !entry.external,
+    )
+    if (
+      !repo?.path ||
+      !/\.(md|txt)$/i.test(relative ?? '') ||
+      relative.split(/[\\/]/).some((segment) => segment.startsWith('.'))
+    )
+      return invalid('document is outside the review surface', 403)
+    try {
+      if (
+        project.configPath &&
+        hashEvidence(
+          JSON.parse(readRegularTextNoFollow(project.configPath)),
+        ) !== hashEvidence(project.config)
+      )
+        return invalid('project changed; restart review', 409)
+      const graph = buildGraph(project)
+      if (
+        graph.errors.length ||
+        !graph.nodes.some(
+          (node) => node.repo === repoName && node.path === relative,
+        )
+      )
+        return invalid('document is not in the valid source graph', 403)
+      return {
+        ok: true,
+        status: 200,
+        ...readBoundedSource(repo.path, relative),
+      }
+    } catch {
+      return invalid('document unavailable or unsafe', 409)
+    }
+  }
+  function handoff(requestId) {
+    const all = records()
+    if (!all.ok) return all
+    const record = all.records.find(
+      (entry) =>
+        entry.input.requestId === requestId &&
+        entry.input.kind === 'decision' &&
+        entry.input.decision === 'accepted',
+    )
+    if (!record) return invalid('accepted decision unavailable', 404)
+    const bound = loadBoundRun(project, record.input.runId)
+    if (!bound.ok) return bound
+    const latest = all.records
+      .filter((entry) => entry.key === record.key)
+      .at(-1)
+    return {
+      ok: true,
+      status: 200,
+      schema: 'atelier-owner-handoff@v1',
+      decision: record,
+      claim: bound.run.claims.find(
+        (claim) => claim.claimId === record.input.targetId,
+      ),
+      requiredEvidenceDigest: bound.snapshot.digest,
+      current:
+        latest.input.requestId === requestId &&
+        currentRunEligibility(project, bound),
+      supersededBy:
+        latest.input.requestId === requestId ? null : latest.input.requestId,
+      sourceChangesApplied: false,
+      promotion: 'not-established',
+      instructions:
+        'Source owner must review the intended edit against current source and record application separately.',
+    }
+  }
+  // One immutable event per aggregate means generic compaction retains every
+  // contribution. Per-target versions are checked inside the ledger write lock.
+  return { records, contribute: contribution, document, handoff }
+}

package/src/commands/coauthor.mjs

@@ -0,0 +1,26 @@
+import { createCoauthorStore } from '../coauthor/store.mjs';
+
+const usage = 'Usage: atelier coauthor start|read|event|recover\nRead one JSON request from stdin (maximum 1 MiB). Start: {"config":...}; read/recover: {"sessionId":...}; event: {"sessionId":...,"event":...}. Workspace is the current directory. Saves are private drafts, not source edits.';
+const command = process.argv[2];
+if (command === '--help' || command === 'help') { console.log(usage); process.exit(0); }
+try {
+  if (!['start', 'read', 'event', 'recover'].includes(command) || process.argv.length !== 3) throw new Error(usage);
+  const chunks = [];
+  let count = 0;
+  for await (const chunk of process.stdin) {
+    count += chunk.length;
+    if (count > 1024 * 1024) throw new Error('request exceeds byte ceiling');
+    chunks.push(chunk);
+  }
+  const input = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('object required');
+  const allowed = command === 'start' ? ['config'] : command === 'event' ? ['sessionId', 'event'] : ['sessionId'];
+  if (Object.keys(input).some(key => !allowed.includes(key)) || allowed.some(key => !Object.hasOwn(input, key))) throw new Error('invalid request fields');
+  const store = createCoauthorStore();
+  const state = command === 'start' ? store.start(input.config) : command === 'read' ? store.read(input.sessionId)
+    : command === 'recover' ? store.recover(input.sessionId) : store.dispatch(input.sessionId, input.event);
+  console.log(JSON.stringify({ ok: true, state, savedMeaning: 'private-draft-only' }));
+} catch (error) {
+  console.error(JSON.stringify({ ok: false, error: error.message }));
+  process.exitCode = 1;
+}

package/src/commands/config.mjs

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
 import { commandProject } from '../project/config.mjs'
 const project = commandProject()
-console.log(JSON.stringify({ ok: true, schema: project.schema, configPath: project.configPath, repos: project.repos.map((repo) => repo.name) }, null, 2))
+const report = process.argv.includes('--explain')
+  ? { ok: true, schema: project.schema, configSource: project.source, repos: project.repos.map((repo) => ({
+    name: repo.name, pathSource: repo.pathSource, resolved: repo.path !== null, readBoundary: repo.readBoundary, external: repo.external,
+  })) }
+  : { ok: true, schema: project.schema, configPath: project.configPath, repos: project.repos.map((repo) => repo.name) }
+console.log(JSON.stringify(report, null, 2))

package/src/commands/extension-pack.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 // atelier extension-pack validate|list
 //
-// Self-contained subcommand parser (no shared CLI plumbing) so the module can
-// be invoked directly: node src/commands/extension-pack.mjs <subcommand> ...
+// Shared project options also work when this module is invoked directly.
 //
 // Exit codes: 0 every enabled pack loads clean (warnings do not fail),
 // 1 an enabled pack failed to load, 2 usage or project resolution error.
@@ -13,6 +12,7 @@
 import path from 'node:path'
 import { ATELIER_EXT_NAMESPACE, loadExtensionPacks } from '../extension-packs/loader.mjs'
 import { asObject, commandProject } from '../project/config.mjs'
+import { PROJECT_OPTION_SPEC, projectOptionAt } from '../cli/project-options.mjs'
 
 const REPORT_SCHEMA = 'mnstry.atelier-extension-pack-report@v1'
 const LIST_SCHEMA = 'mnstry.atelier-extension-pack-list@v1'
@@ -35,6 +35,10 @@ ext["${ATELIER_EXT_NAMESPACE}"].extensionPacks. Pack protocols are resolvable
 by full namespaced id only; the machine-local overlay can disable a declared
 pack but can never enable an undeclared one.
 
+Project options: --project PATH (alias --project-config PATH) and repeated
+--repo-path NAME=PATH also accept --flag=value. Repo overrides resolve from
+the current directory and do not declare new repos or widen read boundaries.
+
 Exit codes: 0 every enabled pack loads clean (warnings do not fail),
 1 an enabled pack failed to load, 2 usage or project resolution error.`
 
@@ -43,10 +47,10 @@ function fail(message) {
   process.exit(2)
 }
 
-// --project / --project-config (both --flag VALUE and --flag=VALUE forms) are
+// Shared project options (both --flag VALUE and --flag=VALUE forms) are
 // recognized here for the unknown-option check only; commandProject reads the
 // same process.argv itself, so the values need no forwarding.
-const OPTION_SPEC = { json: 'flag', project: 'value', 'project-config': 'value' }
+const OPTION_SPEC = { json: 'flag', ...PROJECT_OPTION_SPEC }
 
 function parseOptions(argv) {
   const options = { json: false }
@@ -60,12 +64,15 @@ function parseOptions(argv) {
       fail(`unexpected argument: ${arg}\n\n${USAGE}`)
     }
     const name = arg.slice(2).split('=')[0]
-    if (!(name in OPTION_SPEC)) fail(`unknown option --${name}\n\n${USAGE}`)
+    if (!Object.hasOwn(OPTION_SPEC, name)) fail(`unknown option --${name}\n\n${USAGE}`)
     if (OPTION_SPEC[name] === 'flag') {
       options[name] = true
-    } else if (!arg.includes('=')) {
-      i += 1
-      if (argv[i] === undefined) fail(`--${name} requires a value`)
+    } else {
+      try {
+        i = projectOptionAt(argv, i).nextIndex - 1
+      } catch (error) {
+        fail(error.message)
+      }
     }
   }
   return options