nonotify 0.1.2 → 0.1.4

package/src/config.ts

@@ -1,74 +1,77 @@
-import { homedir } from 'node:os'
-import { join, resolve } from 'node:path'
-import { mkdir, readFile, writeFile, chmod } from 'node:fs/promises'
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { mkdir, readFile, writeFile, chmod } from "node:fs/promises";
 
 export type TelegramProfile = {
-  type: 'telegram'
-  name: string
-  botToken: string
-  chatId: string
-  createdAt: string
-}
+  type: "telegram";
+  name: string;
+  botToken: string;
+  chatId: string;
+  createdAt: string;
+};
 
 export type NntConfig = {
-  defaultProfile: string | null
-  profiles: Record<string, TelegramProfile>
-}
+  defaultProfile: string | null;
+  profiles: Record<string, TelegramProfile>;
+};
 
 const DEFAULT_CONFIG: NntConfig = {
   defaultProfile: null,
   profiles: {},
-}
+};
 
 export function getConfigDir(): string {
-  const dir = process.env.NNT_CONFIG_DIR
-  if (dir && dir.trim() !== '') {
-    return resolve(dir)
+  const dir = process.env.NNT_CONFIG_DIR;
+  if (dir && dir.trim() !== "") {
+    return resolve(dir);
   }
 
-  return join(homedir(), '.nnt')
+  return join(homedir(), ".nnt");
 }
 
 export function getConfigPath(): string {
-  return join(getConfigDir(), 'config')
+  return join(getConfigDir(), "config");
 }
 
 export async function loadConfig(): Promise<NntConfig> {
-  const path = getConfigPath()
+  const path = getConfigPath();
 
   try {
-    const raw = await readFile(path, 'utf8')
-    const parsed = JSON.parse(raw) as Partial<NntConfig>
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw) as Partial<NntConfig>;
 
     return {
-      defaultProfile: typeof parsed.defaultProfile === 'string' ? parsed.defaultProfile : null,
+      defaultProfile:
+        typeof parsed.defaultProfile === "string"
+          ? parsed.defaultProfile
+          : null,
       profiles: parsed.profiles ?? {},
-    }
-  }
-  catch (error) {
-    if (isNodeError(error) && error.code === 'ENOENT') {
-      return { ...DEFAULT_CONFIG }
+    };
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return { ...DEFAULT_CONFIG };
     }
 
-    throw error
+    throw error;
   }
 }
 
 export async function saveConfig(config: NntConfig): Promise<void> {
-  const dir = getConfigDir()
-  const path = getConfigPath()
+  const dir = getConfigDir();
+  const path = getConfigPath();
 
-  await mkdir(dir, { recursive: true })
-  await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 })
+  await mkdir(dir, { recursive: true });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, {
+    mode: 0o600,
+  });
 
   try {
-    await chmod(path, 0o600)
-  }
-  catch {
+    await chmod(path, 0o600);
+  } catch {
     // Best effort only.
   }
 }
 
 function isNodeError(error: unknown): error is NodeJS.ErrnoException {
-  return typeof error === 'object' && error !== null && 'code' in error
+  return typeof error === "object" && error !== null && "code" in error;
 }

package/src/display.ts

@@ -1,38 +1,41 @@
-import Table from 'cli-table3'
+import Table from "cli-table3";
 
 type ProfileRow = {
-  name: string
-  provider: string
-  isDefault: boolean
-}
+  name: string;
+  provider: string;
+  isDefault: boolean;
+};
 
 export function printProfilesTable(rows: ProfileRow[]): void {
   if (rows.length === 0) {
-    process.stdout.write('No profiles configured. Run `nnt profile add`.\n')
-    return
+    process.stdout.write("No profiles configured. Run `nnt profile add`.\n");
+    return;
   }
 
   const table = new Table({
-    head: ['Profile', 'Provider', 'Default'],
-  })
+    head: ["Profile", "Provider", "Default"],
+  });
 
   for (const row of rows) {
-    table.push([row.name, row.provider, row.isDefault ? 'yes' : ''])
+    table.push([row.name, row.provider, row.isDefault ? "yes" : ""]);
   }
 
-  process.stdout.write(`${table.toString()}\n`)
+  process.stdout.write(`${table.toString()}\n`);
 }
 
-export function printKeyValueTable(title: string, rows: Array<{ key: string, value: string }>): void {
-  process.stdout.write(`${title}\n`)
+export function printKeyValueTable(
+  title: string,
+  rows: Array<{ key: string; value: string }>,
+): void {
+  process.stdout.write(`${title}\n`);
 
   const table = new Table({
-    head: ['Field', 'Value'],
-  })
+    head: ["Field", "Value"],
+  });
 
   for (const row of rows) {
-    table.push([row.key, row.value])
+    table.push([row.key, row.value]);
   }
 
-  process.stdout.write(`${table.toString()}\n`)
+  process.stdout.write(`${table.toString()}\n`);
 }

package/src/prompt.ts

@@ -1,67 +1,76 @@
-import { cancel, confirm, isCancel, select, text } from '@clack/prompts'
+import { cancel, confirm, isCancel, select, text } from "@clack/prompts";
 
 export async function askRequired(question: string): Promise<string> {
-  return askRequiredWithInitial(question)
+  return askRequiredWithInitial(question);
 }
 
-export async function askRequiredWithInitial(question: string, initialValue?: string): Promise<string> {
-  const message = normalizeQuestion(question)
+export async function askRequiredWithInitial(
+  question: string,
+  initialValue?: string,
+): Promise<string> {
+  const message = normalizeQuestion(question);
 
   const value = await text({
     message,
     initialValue,
     validate(input) {
-      if (!input || input.trim() === '') {
-        return 'Value cannot be empty'
+      if (!input || input.trim() === "") {
+        return "Value cannot be empty";
       }
 
-      return undefined
+      return undefined;
     },
-  })
+  });
 
   if (isCancel(value)) {
-    cancel('Operation cancelled.')
-    process.exit(1)
+    cancel("Operation cancelled.");
+    process.exit(1);
   }
 
-  return value.trim()
+  return value.trim();
 }
 
-export async function askConfirm(question: string, initialValue = false): Promise<boolean> {
+export async function askConfirm(
+  question: string,
+  initialValue = false,
+): Promise<boolean> {
   const value = await confirm({
     message: normalizeQuestion(question),
     initialValue,
-  })
+  });
 
   if (isCancel(value)) {
-    cancel('Operation cancelled.')
-    process.exit(1)
+    cancel("Operation cancelled.");
+    process.exit(1);
   }
 
-  return value
+  return value;
 }
 
 type SelectOption = {
-  value: string
-  label: string
-  hint?: string
-  disabled?: boolean
-}
+  value: string;
+  label: string;
+  hint?: string;
+  disabled?: boolean;
+};
 
-export async function askSelect(question: string, options: SelectOption[]): Promise<string> {
+export async function askSelect(
+  question: string,
+  options: SelectOption[],
+): Promise<string> {
   const value = await select<string>({
     message: normalizeQuestion(question),
     options,
-  })
+  });
 
   if (isCancel(value)) {
-    cancel('Operation cancelled.')
-    process.exit(1)
+    cancel("Operation cancelled.");
+    process.exit(1);
   }
 
-  return value
+  return value;
 }
 
 function normalizeQuestion(question: string): string {
-  return question.trim().replace(/:\s*$/, '')
+  return question.trim().replace(/:\s*$/, "");
 }

package/src/telegram.ts

@@ -1,71 +1,81 @@
 type TelegramApiResponse<T> =
   | {
-    ok: true
-    result: T
-  }
+      ok: true;
+      result: T;
+    }
   | {
-    ok: false
-    error_code: number
-    description: string
-  }
+      ok: false;
+      error_code: number;
+      description: string;
+    };
 
 type TelegramUpdate = {
-  update_id: number
+  update_id: number;
   message?: {
     from?: {
-      username?: string
-    }
+      username?: string;
+    };
     chat?: {
-      id: number
-      username?: string
-    }
-    text?: string
-  }
-}
+      id: number;
+      username?: string;
+    };
+    text?: string;
+  };
+};
 
 export type TelegramConnection = {
-  chatId: string
-  username: string | null
-}
+  chatId: string;
+  username: string | null;
+};
 
 async function telegramRequest<T>(
   botToken: string,
   method: string,
   payload: Record<string, unknown>,
 ): Promise<T> {
-  const response = await fetch(`https://api.telegram.org/bot${botToken}/${method}`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
+  const response = await fetch(
+    `https://api.telegram.org/bot${botToken}/${method}`,
+    {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify(payload),
     },
-    body: JSON.stringify(payload),
-  })
+  );
 
   if (!response.ok) {
-    throw new Error(`Telegram API HTTP ${response.status}`)
+    throw new Error(`Telegram API HTTP ${response.status}`);
   }
 
-  const json = await response.json() as TelegramApiResponse<T>
+  const json = (await response.json()) as TelegramApiResponse<T>;
 
   if (!json.ok) {
-    throw new Error(json.description)
+    throw new Error(json.description);
   }
 
-  return json.result
+  return json.result;
 }
 
 export async function getLatestUpdateOffset(botToken: string): Promise<number> {
-  const updates = await telegramRequest<TelegramUpdate[]>(botToken, 'getUpdates', {
-    timeout: 0,
-    allowed_updates: ['message'],
-  })
+  const updates = await telegramRequest<TelegramUpdate[]>(
+    botToken,
+    "getUpdates",
+    {
+      timeout: 0,
+      allowed_updates: ["message"],
+    },
+  );
 
   if (updates.length === 0) {
-    return 0
+    return 0;
   }
 
-  const maxUpdateId = updates.reduce((acc, item) => Math.max(acc, item.update_id), 0)
-  return maxUpdateId + 1
+  const maxUpdateId = updates.reduce(
+    (acc, item) => Math.max(acc, item.update_id),
+    0,
+  );
+  return maxUpdateId + 1;
 }
 
 export async function waitForChatId(
@@ -73,37 +83,51 @@ export async function waitForChatId(
   offset: number,
   timeoutSeconds = 120,
 ): Promise<TelegramConnection> {
-  const startedAt = Date.now()
-  let currentOffset = offset
+  const startedAt = Date.now();
+  let currentOffset = offset;
 
   while ((Date.now() - startedAt) / 1000 < timeoutSeconds) {
-    const remainingSeconds = timeoutSeconds - Math.floor((Date.now() - startedAt) / 1000)
-    const pollTimeout = Math.max(1, Math.min(25, remainingSeconds))
-
-    const updates = await telegramRequest<TelegramUpdate[]>(botToken, 'getUpdates', {
-      offset: currentOffset,
-      timeout: pollTimeout,
-      allowed_updates: ['message'],
-    })
+    const remainingSeconds =
+      timeoutSeconds - Math.floor((Date.now() - startedAt) / 1000);
+    const pollTimeout = Math.max(1, Math.min(25, remainingSeconds));
+
+    const updates = await telegramRequest<TelegramUpdate[]>(
+      botToken,
+      "getUpdates",
+      {
+        offset: currentOffset,
+        timeout: pollTimeout,
+        allowed_updates: ["message"],
+      },
+    );
 
     for (const update of updates) {
-      currentOffset = Math.max(currentOffset, update.update_id + 1)
+      currentOffset = Math.max(currentOffset, update.update_id + 1);
 
       if (update.message?.chat?.id !== undefined) {
         return {
           chatId: String(update.message.chat.id),
-          username: update.message.from?.username ?? update.message.chat.username ?? null,
-        }
+          username:
+            update.message.from?.username ??
+            update.message.chat.username ??
+            null,
+        };
       }
     }
   }
 
-  throw new Error('Timed out waiting for Telegram message. Send a message to your bot and try again.')
+  throw new Error(
+    "Timed out waiting for Telegram message. Send a message to your bot and try again.",
+  );
 }
 
-export async function sendTelegramMessage(botToken: string, chatId: string, text: string): Promise<void> {
-  await telegramRequest(botToken, 'sendMessage', {
+export async function sendTelegramMessage(
+  botToken: string,
+  chatId: string,
+  text: string,
+): Promise<void> {
+  await telegramRequest(botToken, "sendMessage", {
     chat_id: chatId,
     text,
-  })
+  });
 }

package/tsconfig.json

@@ -11,7 +11,5 @@
     "outDir": "dist",
     "rootDir": "src"
   },
-  "include": [
-    "src/**/*.ts"
-  ]
+  "include": ["src/**/*.ts"]
 }