Review Implement Phase

{
  "name": "@prisma-next/skill-review-implement-phase",
  "private": true,
  "type": "module",
  "version": "0.0.0",
  "description": "Implement phase package for review-framework skill",
  "scripts": {
    "check-github-admin-ready": "node scripts/check-github-admin-ready.mjs",
    "post-review-thread-reply": "node scripts/post-review-thread-reply.mjs",
    "resolve-review-thread": "node scripts/resolve-review-thread.mjs"
  }
}

#!/usr/bin/env node

import { spawnSync } from 'node:child_process';
import { realpathSync } from 'node:fs';
import { resolve } from 'node:path';
import { fileURLToPath } from 'node:url';

const EXIT_SUCCESS = 0;
const EXIT_OPERATIONAL = 1;
const EXIT_CLI = 2;
const SUBPROCESS_TIMEOUT_MS = 30_000;

function parseCliArgs(argv) {
  const args = argv.slice(2);
  const result = { prUrl: null, help: false };
  if (args.includes('--help')) {
    result.help = true;
    return result;
  }
  for (let index = 0; index < args.length; index += 1) {
    const arg = args[index];
    if (arg !== '--pr') {
      throw { code: EXIT_CLI, message: `error: unknown flag "${arg}"` };
    }
    index += 1;
    if (index >= args.length) {
      throw { code: EXIT_CLI, message: 'error: --pr requires a value' };
    }
    result.prUrl = args[index];
  }
  if (!result.prUrl) {
    throw { code: EXIT_CLI, message: 'error: --pr is required' };
  }
  return result;
}

function getHelpText() {
  return [
    'Usage:',
    '  check-github-admin-ready.mjs --pr <PR_URL>',
    '',
    'Purpose:',
    '  Verify gh authentication + repo scopes and PR API access before implement phase.',
  ].join('\n');
}

function parsePrUrl(url) {
  const match = String(url)
    .trim()
    .match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:\/)?(?:#.*)?$/i);
  if (!match) {
    return null;
  }
  return {
    owner: match[1],
    repo: match[2].replace(/\.git$/, ''),
    number: Number.parseInt(match[3], 10),
  };
}

function run(command, args) {
  const result = spawnSync(command, args, { encoding: 'utf8', timeout: SUBPROCESS_TIMEOUT_MS });
  if (result.error?.code === 'ETIMEDOUT') {
    throw new Error(`error: ${command} timed out after ${SUBPROCESS_TIMEOUT_MS / 1000} seconds`);
  }
  if (result.signal) {
    throw new Error(`error: ${command} was terminated by signal ${result.signal}`);
  }
  return result;
}

function hasRepoScope(output) {
  const scopeLine = output.split(/\r?\n/).find((line) => line.includes('Token scopes:'));
  if (!scopeLine) {
    return false;
  }
  return scopeLine
    .replace(/^.*Token scopes:\s*/u, '')
    .split(',')
    .map((scope) => scope.trim().replace(/^['"]|['"]$/g, ''))
    .includes('repo');
}

function assertCommandAvailable(command, installHint) {
  const probe = run(command, ['--version']);
  if (probe.error || probe.status !== 0) {
    throw new Error(
      `error: required dependency "${command}" is not available. Install ${installHint} and retry.`,
    );
  }
}

function assertGhAuthAndScopes() {
  const auth = run('gh', ['auth', 'status']);
  if (auth.error) {
    throw new Error(`error: failed to execute gh: ${auth.error.message}`);
  }
  if (auth.status !== 0) {
    throw new Error('error: gh is not authenticated; run `gh auth login`.');
  }
  const output = `${auth.stdout}\n${auth.stderr}`;
  if (!hasRepoScope(output)) {
    throw new Error('error: gh token is missing `repo` scope required for review thread admin.');
  }
}

function assertPrApiAccess(owner, repo, number) {
  const query =
    'query($owner:String!,$repo:String!,$number:Int!){repository(owner:$owner,name:$repo){pullRequest(number:$number){id url state}}}';
  const result = run('gh', [
    'api',
    'graphql',
    '-f',
    `query=${query}`,
    '-F',
    `owner=${owner}`,
    '-F',
    `repo=${repo}`,
    '-F',
    `number=${number}`,
  ]);
  if (result.status !== 0) {
    throw new Error(
      `error: cannot access PR via gh api graphql: ${result.stderr || result.stdout}`.trim(),
    );
  }
}

async function main() {
  const args = parseCliArgs(process.argv);
  if (args.help) {
    process.stdout.write(`${getHelpText()}\n`);
    process.exit(EXIT_SUCCESS);
  }

  const parsed = parsePrUrl(args.prUrl);
  if (!parsed) {
    throw {
      code: EXIT_CLI,
      message: 'error: invalid PR URL (expected https://github.com/OWNER/REPO/pull/123)',
    };
  }

  assertCommandAvailable('gh', 'GitHub CLI (`gh`)');

  assertGhAuthAndScopes();
  assertPrApiAccess(parsed.owner, parsed.repo, parsed.number);
  process.stdout.write('ok: github admin preflight passed\n');
}

const isMain = (() => {
  try {
    const invokedScriptPath = process.argv[1] ? realpathSync(resolve(process.argv[1])) : null;
    const currentModulePath = realpathSync(fileURLToPath(import.meta.url));
    return invokedScriptPath !== null && invokedScriptPath === currentModulePath;
  } catch {
    return false;
  }
})();

if (isMain) {
  main().catch((error) => {
    const code = typeof error?.code === 'number' ? error.code : EXIT_OPERATIONAL;
    const message = error?.message ? String(error.message) : String(error);
    process.stderr.write(`${message}\n`);
    process.exit(code);
  });
}

#!/usr/bin/env node

import { spawnSync } from 'node:child_process';
import { readFileSync, realpathSync } from 'node:fs';
import { resolve } from 'node:path';
import { fileURLToPath } from 'node:url';

const EXIT_SUCCESS = 0;
const EXIT_OPERATIONAL = 1;
const EXIT_CLI = 2;
const SUBPROCESS_TIMEOUT_MS = 30_000;

function parseCliArgs(argv) {
  const args = argv.slice(2);
  const result = {
    help: false,
    repo: null,
    prNumber: null,
    commentNodeId: null,
    body: null,
    bodyFile: null,
  };

  if (args.includes('--help')) {
    result.help = true;
    return result;
  }

  for (let index = 0; index < args.length; index += 1) {
    const arg = args[index];
    if (
      arg !== '--repo' &&
      arg !== '--pr' &&
      arg !== '--comment-node-id' &&
      arg !== '--body' &&
      arg !== '--body-file'
    ) {
      throw { code: EXIT_CLI, message: `error: unknown flag "${arg}"` };
    }
    index += 1;
    if (index >= args.length) {
      throw { code: EXIT_CLI, message: `error: ${arg} requires a value` };
    }
    const value = args[index];
    if (arg === '--repo') result.repo = value;
    if (arg === '--pr') result.prNumber = value;
    if (arg === '--comment-node-id') result.commentNodeId = value;
    if (arg === '--body') result.body = value;
    if (arg === '--body-file') result.bodyFile = value;
  }

  if (!result.repo) {
    throw { code: EXIT_CLI, message: 'error: --repo is required (OWNER/REPO)' };
  }
  if (!result.prNumber || !/^[1-9]\d*$/.test(result.prNumber)) {
    throw {
      code: EXIT_CLI,
      message: 'error: --pr is required (positive integer pull request number; e.g. 123)',
    };
  }
  if (!result.commentNodeId) {
    throw { code: EXIT_CLI, message: 'error: --comment-node-id is required' };
  }
  if (result.body === null && result.bodyFile === null) {
    throw { code: EXIT_CLI, message: 'error: provide exactly one of --body or --body-file' };
  }
  if (result.body !== null && result.bodyFile !== null) {
    throw { code: EXIT_CLI, message: 'error: provide only one of --body or --body-file' };
  }

  return result;
}

function getHelpText() {
  return [
    'Usage:',
    '  post-review-thread-reply.mjs --repo <OWNER/REPO> --pr <NUMBER> --comment-node-id <NODE_ID> (--body <TEXT> | --body-file <PATH>)',
    '',
    'Purpose:',
    '  Post acknowledgement to a review-target node and exit with a JSON result.',
    '',
    '  Behaviour by node type (auto-detected via GraphQL):',
    '    * PullRequestReviewComment (inline thread comment, PRRC_…): post an inline',
    '      reply via repos/{repo}/pulls/{pr}/comments with in_reply_to.',
    '    * PullRequestReview (review body, PRR_…): review bodies do not accept inline',
    '      replies, so post a top-level PR issue comment via',
    '      repos/{repo}/issues/{pr}/comments. The response kind is "issue_comment".',
    '',
    '  Anything else exits with a clear "unsupported node kind" error.',
  ].join('\n');
}

function run(command, args, input = null) {
  const result = spawnSync(command, args, {
    encoding: 'utf8',
    input: input ?? undefined,
    timeout: SUBPROCESS_TIMEOUT_MS,
  });
  if (result.error) {
    if (result.error.code === 'ETIMEDOUT') {
      throw new Error(`error: ${command} timed out after ${SUBPROCESS_TIMEOUT_MS / 1000} seconds`);
    }
    throw new Error(`error: failed to execute ${command}: ${result.error.message}`);
  }
  if (result.signal) {
    throw new Error(`error: ${command} was terminated by signal ${result.signal}`);
  }
  if (result.status !== 0) {
    throw new Error(
      `error: ${command} ${args.join(' ')} failed: ${result.stderr || result.stdout}`.trim(),
    );
  }
  return result.stdout;
}

function assertCommandAvailable(command, installHint) {
  const probe = spawnSync(command, ['--version'], {
    encoding: 'utf8',
    timeout: SUBPROCESS_TIMEOUT_MS,
  });
  if (probe.error?.code === 'ETIMEDOUT') {
    throw new Error(
      `error: required dependency "${command}" timed out after ${SUBPROCESS_TIMEOUT_MS / 1000} seconds.`,
    );
  }
  if (probe.signal) {
    throw new Error(
      `error: required dependency "${command}" was terminated by signal ${probe.signal}.`,
    );
  }
  if (probe.error || probe.status !== 0) {
    throw new Error(
      `error: required dependency "${command}" is not available. Install ${installHint} and retry.`,
    );
  }
}

function parseApiResponse(jsonText, contextDescription) {
  let parsed;
  try {
    parsed = JSON.parse(jsonText);
  } catch (parseError) {
    throw new Error(`error: failed to parse ${contextDescription}: ${parseError.message}`);
  }
  if (Array.isArray(parsed?.errors) && parsed.errors.length > 0) {
    const messages = parsed.errors
      .map((err) =>
        typeof err?.message === 'string' && err.message.length > 0
          ? err.message
          : JSON.stringify(err),
      )
      .join('; ');
    throw new Error(`error: ${messages}`);
  }
  return parsed;
}

function resolveTargetNode(commentNodeId) {
  const query = [
    'query($id:ID!){',
    '  node(id:$id){',
    '    __typename',
    '    ... on PullRequestReviewComment {',
    '      databaseId',
    '      pullRequest { number repository { nameWithOwner } }',
    '    }',
    '    ... on PullRequestReview {',
    '      databaseId',
    '      pullRequest { number repository { nameWithOwner } }',
    '    }',
    '  }',
    '}',
  ].join('\n');
  const response = run('gh', [
    'api',
    'graphql',
    '-f',
    `query=${query}`,
    '-F',
    `id=${commentNodeId}`,
  ]);
  const parsed = parseApiResponse(response, 'GraphQL node lookup response');
  const node = parsed?.data?.node;
  if (!node || typeof node !== 'object') {
    throw new Error(`error: GraphQL node lookup returned no node for id ${commentNodeId}`);
  }
  const typename = node.__typename;
  const databaseId =
    typeof node.databaseId === 'number'
      ? node.databaseId
      : typeof node.databaseId === 'string' && node.databaseId.length > 0
        ? Number.parseInt(node.databaseId, 10)
        : null;
  if (typename !== 'PullRequestReviewComment' && typename !== 'PullRequestReview') {
    throw new Error(
      `error: unsupported node kind "${typename ?? 'unknown'}" for ${commentNodeId} (expected PullRequestReviewComment or PullRequestReview)`,
    );
  }
  if (databaseId === null || Number.isNaN(databaseId)) {
    throw new Error(`error: failed to resolve databaseId for ${typename} node ${commentNodeId}`);
  }
  const repo =
    typeof node.pullRequest?.repository?.nameWithOwner === 'string'
      ? node.pullRequest.repository.nameWithOwner
      : null;
  const prNumber = typeof node.pullRequest?.number === 'number' ? node.pullRequest.number : null;
  if (!repo || prNumber === null) {
    throw new Error(
      `error: GraphQL node lookup did not return owning repo and PR for ${commentNodeId}`,
    );
  }
  return { kind: typename, databaseId, repo, prNumber };
}

function assertNodeBelongsTo(target, expectedRepo, expectedPrNumber, commentNodeId) {
  if (target.repo.toLowerCase() !== expectedRepo.toLowerCase()) {
    throw new Error(
      `error: ${commentNodeId} belongs to ${target.repo}#${target.prNumber}, not ${expectedRepo}#${expectedPrNumber}`,
    );
  }
  if (target.prNumber !== expectedPrNumber) {
    throw new Error(
      `error: ${commentNodeId} belongs to ${target.repo}#${target.prNumber}, not ${expectedRepo}#${expectedPrNumber}`,
    );
  }
}

function readBody(body, bodyFile) {
  if (body !== null) {
    return body;
  }
  return readFileSync(resolve(bodyFile), 'utf8');
}

function postInlineReply(repo, prNumber, body, inReplyToDatabaseId) {
  const response = run('gh', [
    'api',
    `repos/${repo}/pulls/${prNumber}/comments`,
    '--method',
    'POST',
    '-f',
    `body=${body}`,
    '-F',
    `in_reply_to=${inReplyToDatabaseId}`,
  ]);
  const parsed = parseApiResponse(response, 'inline-reply REST response');
  if (typeof parsed?.id !== 'number') {
    throw new Error('error: reply was posted but response did not include a numeric comment id');
  }
  return parsed.id;
}

function postIssueComment(repo, prNumber, body) {
  const response = run('gh', [
    'api',
    `repos/${repo}/issues/${prNumber}/comments`,
    '--method',
    'POST',
    '-f',
    `body=${body}`,
  ]);
  const parsed = parseApiResponse(response, 'issue-comment REST response');
  if (typeof parsed?.id !== 'number') {
    throw new Error(
      'error: top-level PR comment was posted but response did not include a numeric comment id',
    );
  }
  return parsed.id;
}

async function main() {
  const args = parseCliArgs(process.argv);
  if (args.help) {
    process.stdout.write(`${getHelpText()}\n`);
    process.exit(EXIT_SUCCESS);
  }

  assertCommandAvailable('gh', 'GitHub CLI (`gh`)');

  const target = resolveTargetNode(args.commentNodeId);
  assertNodeBelongsTo(target, args.repo, Number.parseInt(args.prNumber, 10), args.commentNodeId);
  const body = readBody(args.body, args.bodyFile);

  if (target.kind === 'PullRequestReviewComment') {
    const replyId = postInlineReply(args.repo, args.prNumber, body, target.databaseId);
    process.stdout.write(
      `${JSON.stringify({
        ok: true,
        kind: 'review_thread_reply',
        replyCommentId: replyId,
        inReplyTo: target.databaseId,
        commentNodeId: args.commentNodeId,
      })}\n`,
    );
    return;
  }

  const issueCommentId = postIssueComment(args.repo, args.prNumber, body);
  process.stdout.write(
    `${JSON.stringify({
      ok: true,
      kind: 'issue_comment',
      issueCommentId,
      reviewDatabaseId: target.databaseId,
      commentNodeId: args.commentNodeId,
      note: 'PullRequestReview targets do not accept inline replies; posted a top-level PR issue comment instead.',
    })}\n`,
  );
}

const isMain = (() => {
  try {
    const invokedScriptPath = process.argv[1] ? realpathSync(resolve(process.argv[1])) : null;
    const currentModulePath = realpathSync(fileURLToPath(import.meta.url));
    return invokedScriptPath !== null && invokedScriptPath === currentModulePath;
  } catch {
    return false;
  }
})();

if (isMain) {
  main().catch((error) => {
    const code = typeof error?.code === 'number' ? error.code : EXIT_OPERATIONAL;
    const message = error?.message ? String(error.message) : String(error);
    process.stderr.write(`${message}\n`);
    process.exit(code);
  });
}

#!/usr/bin/env node

import { spawnSync } from 'node:child_process';
import { realpathSync } from 'node:fs';
import { resolve } from 'node:path';
import { fileURLToPath } from 'node:url';

const EXIT_SUCCESS = 0;
const EXIT_OPERATIONAL = 1;
const EXIT_CLI = 2;
const SUBPROCESS_TIMEOUT_MS = 30_000;

function parseCliArgs(argv) {
  const args = argv.slice(2);
  const result = { help: false, threadNodeId: null };
  if (args.includes('--help')) {
    result.help = true;
    return result;
  }
  for (let index = 0; index < args.length; index += 1) {
    const arg = args[index];
    if (arg !== '--thread-node-id') {
      throw { code: EXIT_CLI, message: `error: unknown flag "${arg}"` };
    }
    index += 1;
    if (index >= args.length) {
      throw { code: EXIT_CLI, message: 'error: --thread-node-id requires a value' };
    }
    result.threadNodeId = args[index];
  }
  if (!result.threadNodeId) {
    throw { code: EXIT_CLI, message: 'error: --thread-node-id is required' };
  }
  return result;
}

function getHelpText() {
  return [
    'Usage:',
    '  resolve-review-thread.mjs --thread-node-id <NODE_ID>',
    '',
    'Purpose:',
    '  Resolve a pull request review thread by node ID via GitHub GraphQL API.',
  ].join('\n');
}

function run(command, args, input = null) {
  const result = spawnSync(command, args, {
    encoding: 'utf8',
    input: input ?? undefined,
    timeout: SUBPROCESS_TIMEOUT_MS,
  });
  if (result.error) {
    if (result.error.code === 'ETIMEDOUT') {
      throw new Error(`error: ${command} timed out after ${SUBPROCESS_TIMEOUT_MS / 1000} seconds`);
    }
    throw new Error(`error: failed to execute ${command}: ${result.error.message}`);
  }
  if (result.signal) {
    throw new Error(`error: ${command} was terminated by signal ${result.signal}`);
  }
  if (result.status !== 0) {
    throw new Error(
      `error: ${command} ${args.join(' ')} failed: ${result.stderr || result.stdout}`.trim(),
    );
  }
  return result.stdout;
}

function assertCommandAvailable(command, installHint) {
  const probe = spawnSync(command, ['--version'], {
    encoding: 'utf8',
    timeout: SUBPROCESS_TIMEOUT_MS,
  });
  if (probe.error || probe.status !== 0) {
    if (probe.error?.code === 'ETIMEDOUT') {
      throw new Error(
        `error: required dependency "${command}" timed out after ${SUBPROCESS_TIMEOUT_MS / 1000} seconds.`,
      );
    }
    if (probe.signal) {
      throw new Error(
        `error: required dependency "${command}" was terminated by signal ${probe.signal}.`,
      );
    }
    throw new Error(
      `error: required dependency "${command}" is not available. Install ${installHint} and retry.`,
    );
  }
}

function resolveThread(threadNodeId) {
  const mutation = [
    'mutation($threadId:ID!){',
    '  resolveReviewThread(input:{threadId:$threadId}){',
    '    thread {',
    '      id',
    '      isResolved',
    '    }',
    '  }',
    '}',
  ].join('\n');

  const response = run('gh', [
    'api',
    'graphql',
    '-f',
    `query=${mutation}`,
    '-F',
    `threadId=${threadNodeId}`,
  ]);

  let parsed;
  try {
    parsed = JSON.parse(response);
  } catch (parseError) {
    throw new Error(`error: failed to parse GraphQL response: ${parseError.message}`);
  }

  if (Array.isArray(parsed?.errors) && parsed.errors.length > 0) {
    const messages = parsed.errors
      .map((err) =>
        typeof err?.message === 'string' && err.message.length > 0
          ? err.message
          : JSON.stringify(err),
      )
      .join('; ');
    throw new Error(`error: ${messages}`);
  }

  const thread = parsed?.data?.resolveReviewThread?.thread;
  if (thread?.isResolved !== true) {
    throw new Error(
      `error: thread was not resolved successfully (isResolved=${thread?.isResolved === undefined ? 'null' : String(thread.isResolved)})`,
    );
  }

  return { resolvedThreadId: thread.id, isResolved: true };
}

async function main() {
  const args = parseCliArgs(process.argv);
  if (args.help) {
    process.stdout.write(`${getHelpText()}\n`);
    process.exit(EXIT_SUCCESS);
  }

  assertCommandAvailable('gh', 'GitHub CLI (`gh`)');

  const result = resolveThread(args.threadNodeId);
  process.stdout.write(
    `${JSON.stringify({
      ok: true,
      threadNodeId: args.threadNodeId,
      resolvedThreadId: result.resolvedThreadId,
      isResolved: true,
    })}\n`,
  );
}

const isMain = (() => {
  try {
    const invokedScriptPath = process.argv[1] ? realpathSync(resolve(process.argv[1])) : null;
    const currentModulePath = realpathSync(fileURLToPath(import.meta.url));
    return invokedScriptPath !== null && invokedScriptPath === currentModulePath;
  } catch {
    return false;
  }
})();

if (isMain) {
  main().catch((error) => {
    const code = typeof error?.code === 'number' ? error.code : EXIT_OPERATIONAL;
    const message = error?.message ? String(error.message) : String(error);
    process.stderr.write(`${message}\n`);
    process.exit(code);
  });
}

import assert from 'node:assert/strict';
import { spawnSync } from 'node:child_process';
import { chmod, mkdtemp, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { delimiter, dirname, join, resolve } from 'node:path';
import test from 'node:test';
import { fileURLToPath } from 'node:url';

const scriptPath = resolve(dirname(fileURLToPath(import.meta.url)), 'resolve-review-thread.mjs');

async function createFakeGh() {
  const directory = await mkdtemp(join(tmpdir(), 'resolve-review-thread-test-'));
  const ghPath = join(directory, 'gh');
  await writeFile(
    ghPath,
    [
      '#!/usr/bin/env node',
      "if (process.argv[2] === '--version') {",
      "  process.stdout.write('gh version fake\\n');",
      '  process.exit(0);',
      '}',
      "process.stdout.write(process.env.FAKE_GH_STDOUT ?? '{}');",
      '',
    ].join('\n'),
    'utf8',
  );
  await chmod(ghPath, 0o755);
  return directory;
}

async function runResolve(args, fakeStdout) {
  const fakeGhDirectory = await createFakeGh();
  return spawnSync(process.execPath, [scriptPath, ...args], {
    encoding: 'utf8',
    env: {
      ...process.env,
      PATH: `${fakeGhDirectory}${delimiter}${process.env.PATH ?? ''}`,
      FAKE_GH_STDOUT: fakeStdout,
    },
  });
}

test('rejects unknown CLI flags', () => {
  const result = spawnSync(process.execPath, [scriptPath, '--bogus'], { encoding: 'utf8' });

  assert.equal(result.status, 2);
  assert.match(result.stderr, /unknown flag "--bogus"/);
});

test('rejects missing thread id', () => {
  const result = spawnSync(process.execPath, [scriptPath], { encoding: 'utf8' });

  assert.equal(result.status, 2);
  assert.match(result.stderr, /--thread-node-id is required/);
});

test('reports malformed JSON responses', async () => {
  const result = await runResolve(['--thread-node-id', 'THREAD_1'], 'not json');

  assert.equal(result.status, 1);
  assert.match(result.stderr, /failed to parse GraphQL response/);
});

test('reports GraphQL errors', async () => {
  const result = await runResolve(
    ['--thread-node-id', 'THREAD_1'],
    JSON.stringify({ errors: [{ message: 'Could not resolve thread' }] }),
  );

  assert.equal(result.status, 1);
  assert.match(result.stderr, /Could not resolve thread/);
});

test('reports unresolved mutation payloads', async () => {
  const result = await runResolve(
    ['--thread-node-id', 'THREAD_1'],
    JSON.stringify({
      data: {
        resolveReviewThread: {
          thread: { id: 'THREAD_1', isResolved: false },
        },
      },
    }),
  );

  assert.equal(result.status, 1);
  assert.match(result.stderr, /thread was not resolved successfully/);
});

test('prints resolution payloads', async () => {
  const result = await runResolve(
    ['--thread-node-id', 'THREAD_1'],
    JSON.stringify({
      data: {
        resolveReviewThread: {
          thread: { id: 'THREAD_1', isResolved: true },
        },
      },
    }),
  );

  assert.equal(result.status, 0);
  assert.deepEqual(JSON.parse(result.stdout), {
    ok: true,
    threadNodeId: 'THREAD_1',
    resolvedThreadId: 'THREAD_1',
    isResolved: true,
  });
});