@tiongcreative/assistant-mcp 0.1.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.3.0] - 2026-10-19
+
+### Added
+
+- Lists & Notes can now be changed, with Lists & Notes 1.23.0 or later: `lists_and_notes_add_items`, `lists_and_notes_update_items` (tick, untick, reword or annotate items named by their text), `lists_and_notes_add_list`, `lists_and_notes_add_note` and `lists_and_notes_update_note` (append, replace or rename). Changes to an existing list or note send the `modified` stamp last read; if the user changed it in the meantime the app refuses, and the tool re-reads and retries once. Item ids are always sent back. An older Lists & Notes gets a message saying which version writes need. No delete tool. End-to-end test against the real 1.23.0 server.
+
+## [0.2.0] - 2026-10-19
+
+### Added
+
+- `npx @tiongcreative/assistant-mcp install` sets the assistant up in Claude Desktop: adds one entry to its config file with the full path to npx (a desktop app cannot see the shell's PATH), keeps a backup, refuses to touch a file it cannot parse, and prints the next steps. `uninstall` removes the entry; `status` reports it. `--allow-fresh` passes npm's release-age override into the entry for Macs that refuse packages younger than a few days. Unit tests cover create, merge, idempotence, corrupt files and removal.
+
+### Changed
+
+- README setup is now the one-command path.
+
 ## [0.1.1] - 2026-10-19
 
 ### Changed

package/README.md

@@ -10,34 +10,35 @@ nothing else happens.
 
 ## Apps
 
-| App                           | Reads                                                                                                            | Changes                                                                                    |
-| ----------------------------- | ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
-| Due Again 1.1.0 or later      | items with status and next due date, an item's history                                                           | add an item, record that an item was done                                                  |
-| Gift Keeper 1.3.0 or later    | people with interests, sizes and preferences; upcoming occasions with budget, spend and whether a gift is chosen | add a gift idea for a person, mark a gift as given                                         |
-| Client Manager 1.6.0 or later | pending reminders, open tasks, invoices owing with totals and balance, one client with their jobs                | add a client, a job, a reminder or a task, change a job, task or reminder, log an activity |
-| Lists & Notes 1.22.0 or later | lists with their items, notes with previews, the full text of a note                                             | nothing yet                                                                                |
+| App                                                 | Reads                                                                                                            | Changes                                                                                    |
+| --------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
+| Due Again 1.1.0 or later                            | items with status and next due date, an item's history                                                           | add an item, record that an item was done                                                  |
+| Gift Keeper 1.3.0 or later                          | people with interests, sizes and preferences; upcoming occasions with budget, spend and whether a gift is chosen | add a gift idea for a person, mark a gift as given                                         |
+| Client Manager 1.6.0 or later                       | pending reminders, open tasks, invoices owing with totals and balance, one client with their jobs                | add a client, a job, a reminder or a task, change a job, task or reminder, log an activity |
+| Lists & Notes 1.22.0 or later (changes need 1.23.0) | lists with their items, notes with previews, the full text of a note                                             | add a list or a note, add items, tick off or reword items, add to or rename a note         |
 
 More apps follow, and the assistant can also open an app for you, but only after you agree.
 
 ## Setup
 
-You need Node.js 20 or later and Claude Desktop. Add this to Claude Desktop's config file
-(Settings → Developer → Edit Config), then restart Claude Desktop:
-
-```json
-{
-  "mcpServers": {
-    "tiongcreative": {
-      "command": "npx",
-      "args": ["-y", "@tiongcreative/assistant-mcp"]
-    }
-  }
-}
+You need Node.js and Claude Desktop. If you do not have Node.js, install it from
+nodejs.org (the LTS download), which also gives you the `npx` command used below.
+
+Open Terminal and run:
+
+```
+npx @tiongcreative/assistant-mcp install
 ```
 
-In each app, turn on **Allow assistant access** in Settings. Open the app, then ask Claude
-what's on. The assistant only offers tools for the apps installed on your Mac, checked when it
-starts, so after installing another app restart Claude Desktop once.
+It adds the assistant to Claude Desktop's settings and keeps a backup of the previous file.
+Then quit Claude Desktop completely, open it again, and allow the "tiongcreative" server the
+first time it asks. In each app, turn on **Allow assistant access** in Settings. With the apps
+open, ask Claude what's on this week.
+
+The assistant only offers tools for the apps installed on your Mac, checked when Claude
+Desktop starts it, so after installing another app restart Claude Desktop once.
+
+To remove it: `npx @tiongcreative/assistant-mcp uninstall`. To check: `npx @tiongcreative/assistant-mcp status`.
 
 For Claude Code: `claude mcp add tiongcreative -- npx -y @tiongcreative/assistant-mcp`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiongcreative/assistant-mcp",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "MCP server that lets an AI assistant on your Mac use your Tiong Creative apps while they are open.",
   "type": "module",
   "bin": {
@@ -34,7 +34,7 @@
     "prepare": "husky",
     "validate": "npm run lint && npm run format:check",
     "quality": "npm run validate && npm run sast && npm run security && npm run secrets && npm run licenses && npm run deps:check && npm run review",
-    "test:unit": "node --test tests/dates.test.js",
+    "test:unit": "node --test tests/dates.test.js tests/install.test.js",
     "test:integration": "node --test tests/due-again.test.js tests/gift-keeper.test.js tests/client-manager.test.js tests/lists-and-notes.test.js"
   },
   "license": "MIT",

package/src/apps/lists-and-notes.js

@@ -1,9 +1,12 @@
-// Lists & Notes: checklists and markdown notes. Read-only for now: the app's list
-// endpoint replaces the whole file from the request, so writes wait until that is
-// hardened (see the plan). Talks to the app's local API with the per-launch token it
-// writes while "Allow assistant access" is on (list-manager/assistant-access.js).
+// Lists & Notes: checklists and markdown notes. Writes need Lists & Notes 1.23.0 or later,
+// which gives the assistant its own per-list and per-note routes (the whole-file save is
+// window-only). Changing an existing list or note sends the `modified` stamp last read
+// (`baseModified`); if the user changed it since, the app refuses and the tool re-reads and
+// retries once. Item ids are always sent back, or the app would treat items as new. There
+// is no delete tool. Talks to the app's local API with the per-launch token it writes while
+// "Allow assistant access" is on (list-manager/assistant-access.js).
 import { z } from 'zod';
-import { appConnection, apiCall, notAvailable } from '../connection.js';
+import { ApiError, appConnection, apiCall, notAvailable } from '../connection.js';
 
 export const app = {
   id: 'lists-and-notes',
@@ -47,6 +50,63 @@ function matches(text, q) {
   return typeof text === 'string' && text.toLowerCase().includes(q);
 }
 
+const WRITES_FROM = '1.23.0';
+
+function olderThan(version, min) {
+  const a = String(version ?? '0')
+    .split('.')
+    .map(Number);
+  const b = min.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] || 0) !== b[i]) return (a[i] || 0) < b[i];
+  }
+  return false;
+}
+
+/** The app's version must support writes; returns a result to send back, or null. */
+function needsUpdate(conn) {
+  if (!olderThan(conn.version, WRITES_FROM)) return null;
+  return {
+    app: app.name,
+    changed: false,
+    message: `Changing lists and notes needs Lists & Notes ${WRITES_FROM} or later (this Mac has ${conn.version ?? 'an older version'}). Reading still works.`,
+  };
+}
+
+async function findList(conn, name) {
+  const lists = await apiCall(conn, 'GET', '/api/data/lists');
+  const wanted = name.trim().toLowerCase();
+  return {
+    list: lists.find((l) => l.name.toLowerCase() === wanted),
+    names: lists.map((l) => l.name),
+  };
+}
+
+async function findNote(conn, title) {
+  const notes = await apiCall(conn, 'GET', '/api/data/notes');
+  const wanted = title.trim().toLowerCase();
+  return {
+    note: notes.find((n) => n.title.toLowerCase() === wanted),
+    titles: notes.map((n) => n.title),
+  };
+}
+
+/** Runs a change against the latest copy; on a 409 (changed in the window) re-reads once. */
+async function withRetry(load, change) {
+  let current = await load();
+  try {
+    return await change(current);
+  } catch (err) {
+    if (!(err instanceof ApiError) || err.status !== 409) throw err;
+    current = await load();
+    return change(current);
+  }
+}
+
+function itemMatches(item, text) {
+  return item.text.trim().toLowerCase() === text.trim().toLowerCase();
+}
+
 export const tools = [
   {
     name: 'lists_and_notes_lists',
@@ -156,6 +216,248 @@ export const tools = [
       };
     },
   },
+  {
+    name: 'lists_and_notes_add_items',
+    description:
+      'Add items to an existing list in Lists & Notes, by list name. Items are added unticked at the end. If the list does not exist, the reply lists the lists.',
+    input: z.object({
+      list: z.string().min(1).max(75),
+      items: z.array(z.string().trim().min(1).max(2000)).min(1).max(100),
+    }),
+    write: true,
+    async run(input) {
+      const conn = await appConnection(app);
+      if (!conn.ok) return notAvailable(app, conn);
+      const old = needsUpdate(conn);
+      if (old) return old;
+      const { list, names } = await findList(conn, input.list);
+      if (!list)
+        return {
+          app: app.name,
+          changed: false,
+          message: `No list called "${input.list}".`,
+          lists: names,
+        };
+      const updated = await apiCall(
+        conn,
+        'POST',
+        `/api/data/lists/${encodeURIComponent(list.id)}/items`,
+        {
+          items: input.items.map((text) => ({ text })),
+        },
+      );
+      return { app: app.name, changed: true, list: summariseList(updated), added: input.items };
+    },
+  },
+  {
+    name: 'lists_and_notes_update_items',
+    description:
+      "Tick off, untick, reword or add notes to items on a list in Lists & Notes. Name the list and each item by its current text. Items not mentioned are left as they are. If an item's text does not match, the reply lists the items.",
+    input: z.object({
+      list: z.string().min(1).max(75),
+      changes: z
+        .array(
+          z.object({
+            item: z.string().min(1).max(2000).describe('The item as it reads now'),
+            done: z.boolean().optional(),
+            text: z.string().trim().min(1).max(2000).optional().describe('New wording'),
+            notes: z.string().max(2000).optional(),
+          }),
+        )
+        .min(1)
+        .max(100),
+    }),
+    write: true,
+    async run(input) {
+      const conn = await appConnection(app);
+      if (!conn.ok) return notAvailable(app, conn);
+      const old = needsUpdate(conn);
+      if (old) return old;
+      const first = await findList(conn, input.list);
+      if (!first.list)
+        return {
+          app: app.name,
+          changed: false,
+          message: `No list called "${input.list}".`,
+          lists: first.names,
+        };
+      const id = first.list.id;
+      const load = async () =>
+        (await apiCall(conn, 'GET', '/api/data/lists')).find((l) => l.id === id);
+      return withRetry(load, async (list) => {
+        if (!list)
+          return { app: app.name, changed: false, message: 'That list has just been removed.' };
+        const items = (list.items ?? []).map((i) => ({ ...i }));
+        const missing = input.changes
+          .filter((c) => !items.some((i) => itemMatches(i, c.item)))
+          .map((c) => c.item);
+        if (missing.length) {
+          return {
+            app: app.name,
+            changed: false,
+            message: `No item reading ${missing.map((m) => `"${m}"`).join(', ')} on ${list.name}.`,
+            items: items.map((i) => i.text),
+          };
+        }
+        for (const c of input.changes) {
+          const item = items.find((i) => itemMatches(i, c.item));
+          if (c.done !== undefined) item.completed = c.done;
+          if (c.text !== undefined) item.text = c.text;
+          if (c.notes !== undefined) item.notes = c.notes;
+        }
+        const updated = await apiCall(conn, 'PATCH', `/api/data/lists/${encodeURIComponent(id)}`, {
+          items,
+          baseModified: list.metadata?.modified,
+        });
+        return { app: app.name, changed: true, list: summariseList(updated) };
+      });
+    },
+  },
+  {
+    name: 'lists_and_notes_add_list',
+    description:
+      'Create a new list in Lists & Notes with optional first items. The category must already exist in the app; if it does not, the reply lists the categories.',
+    input: z.object({
+      name: z.string().trim().min(1).max(75),
+      items: z.array(z.string().trim().min(1).max(2000)).max(100).optional(),
+      category: z.string().max(100).optional().describe('Defaults to personal'),
+      tags: z.array(z.string().max(50)).max(10).optional(),
+    }),
+    write: true,
+    async run(input) {
+      const conn = await appConnection(app);
+      if (!conn.ok) return notAvailable(app, conn);
+      const old = needsUpdate(conn);
+      if (old) return old;
+      const [{ list: existing }, categories] = await Promise.all([
+        findList(conn, input.name),
+        apiCall(conn, 'GET', '/api/data/categories'),
+      ]);
+      if (existing)
+        return {
+          app: app.name,
+          added: false,
+          message: `There is already a list called "${input.name}".`,
+        };
+      const category = input.category
+        ? categories.find((c) => c.toLowerCase() === input.category.trim().toLowerCase())
+        : 'personal';
+      if (!category)
+        return {
+          app: app.name,
+          added: false,
+          message: `No category called "${input.category}".`,
+          categories,
+        };
+      const list = await apiCall(conn, 'POST', '/api/data/lists/add', {
+        name: input.name,
+        category,
+        ...(input.tags ? { tags: input.tags } : {}),
+        items: (input.items ?? []).map((text) => ({ text, completed: false, notes: '' })),
+      });
+      return { app: app.name, added: true, list: summariseList(list) };
+    },
+  },
+  {
+    name: 'lists_and_notes_add_note',
+    description:
+      'Create a note in Lists & Notes with a title and markdown content. The category must already exist; if it does not, the reply lists the categories.',
+    input: z.object({
+      title: z.string().trim().min(1).max(75),
+      content: z.string().max(200000).default(''),
+      category: z.string().max(100).optional().describe('Defaults to personal'),
+      tags: z.array(z.string().max(50)).max(10).optional(),
+    }),
+    write: true,
+    async run(input) {
+      const conn = await appConnection(app);
+      if (!conn.ok) return notAvailable(app, conn);
+      const old = needsUpdate(conn);
+      if (old) return old;
+      const categories = await apiCall(conn, 'GET', '/api/data/categories');
+      const category = input.category
+        ? categories.find((c) => c.toLowerCase() === input.category.trim().toLowerCase())
+        : 'personal';
+      if (!category)
+        return {
+          app: app.name,
+          added: false,
+          message: `No category called "${input.category}".`,
+          categories,
+        };
+      const note = await apiCall(conn, 'POST', '/api/data/notes', {
+        title: input.title,
+        category,
+        content: input.content,
+        ...(input.tags ? { tags: input.tags } : {}),
+      });
+      return { app: app.name, added: true, note: summariseNote(note) };
+    },
+  },
+  {
+    name: 'lists_and_notes_update_note',
+    description:
+      "Change a note in Lists & Notes, by title: add text to the end (append), replace its text, or rename it. If the user edits the note at the same moment, the change is applied to their latest version; the app keeps the previous text in the note's history.",
+    input: z.object({
+      title: z.string().min(1).max(75).describe('The note as it is titled now'),
+      append: z.string().max(200000).optional().describe('Text added on a new line at the end'),
+      content: z.string().max(200000).optional().describe('Replaces the whole text'),
+      newTitle: z.string().trim().min(1).max(75).optional(),
+    }),
+    write: true,
+    async run(input) {
+      const conn = await appConnection(app);
+      if (!conn.ok) return notAvailable(app, conn);
+      const old = needsUpdate(conn);
+      if (old) return old;
+      if (
+        input.append === undefined &&
+        input.content === undefined &&
+        input.newTitle === undefined
+      ) {
+        return {
+          app: app.name,
+          changed: false,
+          message: 'Nothing to change: give text to append, new content or a new title.',
+        };
+      }
+      if (input.append !== undefined && input.content !== undefined) {
+        return {
+          app: app.name,
+          changed: false,
+          message: 'Give either append or content, not both.',
+        };
+      }
+      const first = await findNote(conn, input.title);
+      if (!first.note)
+        return {
+          app: app.name,
+          changed: false,
+          message: `No note called "${input.title}".`,
+          titles: first.titles,
+        };
+      const id = first.note.id;
+      const load = () => apiCall(conn, 'GET', `/api/data/notes/${encodeURIComponent(id)}`);
+      return withRetry(load, async (note) => {
+        const body = { baseModified: note.metadata?.modified };
+        if (input.content !== undefined) body.content = input.content;
+        if (input.append !== undefined) {
+          const current = typeof note.content === 'string' ? note.content : '';
+          body.content = current
+            ? `${current.replace(/\s+$/, '')}\n\n${input.append}`
+            : input.append;
+        }
+        if (input.newTitle !== undefined) body.title = input.newTitle;
+        const updated = await apiCall(
+          conn,
+          'PUT',
+          `/api/data/notes/${encodeURIComponent(id)}`,
+          body,
+        );
+        return { app: app.name, changed: true, note: summariseNote(updated) };
+      });
+    },
+  },
 ];
 
 /** Lists & Notes has no dated items, so it adds nothing to "what's on". */

package/src/index.js

@@ -11,6 +11,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import { ApiError, isInstalled } from './connection.js';
+import { runCli } from './install.js';
 import * as dueAgain from './apps/due-again.js';
 import * as giftKeeper from './apps/gift-keeper.js';
 import * as clientManager from './apps/client-manager.js';
@@ -18,6 +19,12 @@ import * as listsAndNotes from './apps/lists-and-notes.js';
 
 const { version } = createRequire(import.meta.url)('../package.json');
 
+// `npx @tiongcreative/assistant-mcp install|uninstall|status` is the member's setup path.
+// With no command, this process is the MCP server Claude Desktop launches.
+if (process.argv.length > 2) {
+  process.exit(runCli(process.argv.slice(2)));
+}
+
 // One entry per app. Add an app by adding a module with the same shape.
 const ALL_APPS = [dueAgain, giftKeeper, clientManager, listsAndNotes];
 // Only apps present on this Mac get tools, so the assistant never points the user at an

package/src/install.js

@@ -0,0 +1,156 @@
+// `npx @tiongcreative/assistant-mcp install`: sets the assistant up in Claude Desktop so a
+// member never edits JSON by hand. It adds one entry to Claude Desktop's config file (and
+// nothing else), keeps a backup, and records the full path to npx, because a desktop app
+// does not see the shell's PATH and would otherwise fail to find it.
+//
+// `uninstall` removes the entry. `status` says whether it is set up.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const SERVER_KEY = 'tiongcreative';
+const PACKAGE = '@tiongcreative/assistant-mcp';
+
+/** Claude Desktop's config file on this Mac (TC_CLAUDE_CONFIG overrides it, for tests). */
+export function configPath() {
+  if (process.env.TC_CLAUDE_CONFIG) return process.env.TC_CLAUDE_CONFIG;
+  if (process.platform !== 'darwin') {
+    throw new Error('The Tiong Creative apps run on macOS, so this installer does too.');
+  }
+  return path.join(
+    os.homedir(),
+    'Library',
+    'Application Support',
+    'Claude',
+    'claude_desktop_config.json',
+  );
+}
+
+/** The npx beside the node that is running this command: the one Claude Desktop will use. */
+export function npxPath() {
+  const candidate = path.join(path.dirname(process.execPath), 'npx');
+  if (fs.existsSync(candidate)) return candidate;
+  throw new Error(`Could not find npx next to node at ${process.execPath}.`);
+}
+
+function readConfig(file) {
+  if (!fs.existsSync(file)) return { config: {}, existed: false };
+  const raw = fs.readFileSync(file, 'utf8');
+  if (!raw.trim()) return { config: {}, existed: true };
+  try {
+    const config = JSON.parse(raw);
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      throw new Error('not an object');
+    }
+    return { config, existed: true };
+  } catch (err) {
+    throw new Error(
+      `Claude Desktop's config file could not be read as JSON (${err.message}), so nothing was changed. File: ${file}`,
+    );
+  }
+}
+
+function writeConfig(file, config, existed) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  let backup = null;
+  if (existed) {
+    backup = `${file}.backup-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+    fs.copyFileSync(file, backup);
+  }
+  const tmp = `${file}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n');
+  fs.renameSync(tmp, file);
+  return backup;
+}
+
+export function install({ env } = {}) {
+  const file = configPath();
+  const { config, existed } = readConfig(file);
+  const entry = { command: npxPath(), args: ['-y', PACKAGE] };
+  if (env && Object.keys(env).length) entry.env = env;
+  const servers =
+    config.mcpServers && typeof config.mcpServers === 'object' ? config.mcpServers : {};
+  const already = JSON.stringify(servers[SERVER_KEY]) === JSON.stringify(entry);
+  config.mcpServers = { ...servers, [SERVER_KEY]: entry };
+  const backup = already ? null : writeConfig(file, config, existed);
+  return { file, backup, already, entry };
+}
+
+export function uninstall() {
+  const file = configPath();
+  const { config, existed } = readConfig(file);
+  if (!existed || !config.mcpServers || !(SERVER_KEY in config.mcpServers)) {
+    return { file, removed: false };
+  }
+  const rest = { ...config.mcpServers };
+  delete rest[SERVER_KEY];
+  config.mcpServers = rest;
+  const backup = writeConfig(file, config, true);
+  return { file, removed: true, backup };
+}
+
+export function status() {
+  const file = configPath();
+  try {
+    const { config, existed } = readConfig(file);
+    const entry = existed ? config.mcpServers?.[SERVER_KEY] : undefined;
+    return { file, installed: !!entry, entry: entry ?? null };
+  } catch (err) {
+    return { file, installed: false, error: err.message };
+  }
+}
+
+const NEXT_STEPS = [
+  '1. Quit Claude Desktop completely and open it again.',
+  '2. The first time you chat, allow the "tiongcreative" server when Claude Desktop asks.',
+  '3. In each Tiong Creative app, open Settings and turn on "Allow assistant access".',
+  '4. With the apps open, ask Claude what is on this week.',
+];
+
+/** Runs the command and returns the process exit code. Prints with the given writer. */
+export function runCli(args, print = console.log) {
+  const [command] = args;
+  try {
+    if (command === 'install') {
+      const env = {};
+      // Developer convenience: `install --allow-fresh` passes npm's release-age override
+      // through to the server entry, for Macs that refuse packages younger than a few days.
+      if (args.includes('--allow-fresh')) env.npm_config_min_release_age = '0';
+      const r = install({ env });
+      print(
+        r.already
+          ? `The Tiong Creative assistant is already set up in Claude Desktop (${r.file}).`
+          : `Added the Tiong Creative assistant to Claude Desktop.\n  Config: ${r.file}${r.backup ? `\n  Backup of the previous file: ${r.backup}` : ''}`,
+      );
+      print('\nNext:\n' + NEXT_STEPS.join('\n'));
+      return 0;
+    }
+    if (command === 'uninstall') {
+      const r = uninstall();
+      print(
+        r.removed
+          ? `Removed the Tiong Creative assistant from Claude Desktop (${r.file}). Restart Claude Desktop to finish.`
+          : `The Tiong Creative assistant was not set up in Claude Desktop (${r.file}), so nothing changed.`,
+      );
+      return 0;
+    }
+    if (command === 'status') {
+      const r = status();
+      if (r.error) print(r.error);
+      else
+        print(
+          r.installed
+            ? `Set up in Claude Desktop: ${r.file}`
+            : `Not set up in Claude Desktop (${r.file}).`,
+        );
+      return 0;
+    }
+    print(
+      `Usage:\n  npx ${PACKAGE} install     add the assistant to Claude Desktop\n  npx ${PACKAGE} uninstall   remove it\n  npx ${PACKAGE} status      say whether it is set up\n\nWith no command, this runs the MCP server itself (Claude Desktop does that for you).`,
+    );
+    return command === 'help' || command === '--help' ? 0 : 2;
+  } catch (err) {
+    print(`Could not finish: ${err.message}`);
+    return 1;
+  }
+}