@openparachute/agent 0.1.1 → 0.2.0

package/src/web/services-manifest.test.ts

@@ -1,120 +0,0 @@
-/**
- * Round-trip tests for the services.json upsert. Mirrors scribe's coverage
- * — the cross-service contract here is the on-disk shape, so we verify
- * exactly that: a fresh write produces the canonical schema, a second
- * upsert with the same name replaces in-place rather than duplicating,
- * and an upsert with a different name appends.
- */
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { upsertService } from './services-manifest.js';
-
-let tmp: string;
-let path: string;
-
-beforeEach(() => {
-  tmp = mkdtempSync(join(tmpdir(), 'paraclaw-services-'));
-  path = join(tmp, 'services.json');
-});
-
-afterEach(() => {
-  rmSync(tmp, { recursive: true, force: true });
-});
-
-describe('upsertService', () => {
-  it('creates the file + writes the canonical entry shape', () => {
-    upsertService(
-      {
-        name: 'agent',
-        port: 1944,
-        paths: ['/agent'],
-        health: '/api/health',
-        version: '0.0.6-rc.1',
-        displayName: 'Parachute Agent',
-        tagline: 'Manage your Parachute agent groups + vault attachments.',
-      },
-      path,
-    );
-    const raw = JSON.parse(readFileSync(path, 'utf8'));
-    expect(raw).toEqual({
-      services: [
-        {
-          name: 'agent',
-          port: 1944,
-          paths: ['/agent'],
-          health: '/api/health',
-          version: '0.0.6-rc.1',
-          displayName: 'Parachute Agent',
-          tagline: 'Manage your Parachute agent groups + vault attachments.',
-        },
-      ],
-    });
-  });
-
-  it('replaces an existing entry with the same name in-place', () => {
-    upsertService({ name: 'agent', port: 1944, paths: ['/agent'], health: '/api/health', version: 'a' }, path);
-    upsertService({ name: 'agent', port: 1944, paths: ['/agent'], health: '/api/health', version: 'b' }, path);
-    const raw = JSON.parse(readFileSync(path, 'utf8')) as { services: { version: string }[] };
-    expect(raw.services).toHaveLength(1);
-    expect(raw.services[0].version).toBe('b');
-  });
-
-  it('appends a different-name entry without disturbing existing rows', () => {
-    upsertService({ name: 'vault', port: 1940, paths: ['/vault'], health: '/health', version: '0.3.0' }, path);
-    upsertService({ name: 'agent', port: 1944, paths: ['/agent'], health: '/api/health', version: '0.0.6-rc.1' }, path);
-    const raw = JSON.parse(readFileSync(path, 'utf8')) as {
-      services: { name: string }[];
-    };
-    expect(raw.services.map((s) => s.name).sort()).toEqual(['agent', 'vault']);
-  });
-
-  it('preserves hub-stamped fields on the row (e.g. installDir from parachute-hub#84)', () => {
-    // The hub stamps `installDir` onto the row at install time. Paraclaw's
-    // self-registration row shape doesn't know about that field, but the
-    // upsert must merge rather than replace so the hub-stamped value
-    // survives the second write — otherwise `parachute start agent` after
-    // an auto-start round-trip can't resolve installDir → "unknown service".
-    writeFileSync(
-      path,
-      JSON.stringify({
-        services: [
-          {
-            name: 'agent',
-            port: 1944,
-            paths: ['/agent'],
-            health: '/api/health',
-            version: '0.0.7-rc.1',
-            installDir: '/Users/test/.parachute/agent',
-          },
-        ],
-      }),
-    );
-    upsertService(
-      {
-        name: 'agent',
-        port: 1944,
-        paths: ['/agent'],
-        health: '/api/health',
-        version: '0.0.8-rc.1',
-      },
-      path,
-    );
-    const raw = JSON.parse(readFileSync(path, 'utf8')) as {
-      services: { version: string; installDir?: string }[];
-    };
-    expect(raw.services).toHaveLength(1);
-    expect(raw.services[0].version).toBe('0.0.8-rc.1');
-    expect(raw.services[0].installDir).toBe('/Users/test/.parachute/agent');
-  });
-
-  it('throws on a malformed existing manifest (so we never silently overwrite)', () => {
-    writeFileSync(path, '{"services": "not an array"}');
-    expect(() =>
-      upsertService({ name: 'agent', port: 1944, paths: ['/agent'], health: '/api/health', version: 'x' }, path),
-    ).toThrow(/malformed/);
-  });
-});

package/src/web/services-manifest.ts

@@ -1,61 +0,0 @@
-/**
- * Self-registration into `~/.parachute/services.json` on server startup.
- *
- * Mirrors `parachute-scribe/src/services-manifest.ts` deliberately — the
- * shape is the contract between every Parachute service and the hub
- * (`parachute-hub/src/services-manifest.ts` is the canonical reader).
- * Once paraclaw earns a slot in the hub's vendored fallback, the
- * manifest read flips to `.parachute/module.json`-backed and this file
- * becomes the live state-side companion. Until then, this is what makes
- * `parachute status` / `parachute expose` see paraclaw at all.
- *
- * Failure mode: any write error is logged + swallowed. Self-registration
- * is best-effort — the server still serves locally even if the manifest
- * write fails (permissions, disk full, race with another writer).
- */
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-
-import { PARACHUTE_DIR } from '../config.js';
-
-export interface ServiceEntry {
-  name: string;
-  port: number;
-  paths: string[];
-  health: string;
-  version: string;
-  displayName?: string;
-  tagline?: string;
-}
-
-interface ServicesManifest {
-  services: ServiceEntry[];
-}
-
-export function resolveManifestPath(): string {
-  return join(PARACHUTE_DIR, 'services.json');
-}
-
-function readManifest(path: string): ServicesManifest {
-  if (!existsSync(path)) return { services: [] };
-  const raw = JSON.parse(readFileSync(path, 'utf8'));
-  if (!raw || typeof raw !== 'object' || !Array.isArray((raw as { services?: unknown }).services)) {
-    throw new Error(`services manifest at ${path} is malformed (missing "services" array)`);
-  }
-  return raw as ServicesManifest;
-}
-
-export function upsertService(entry: ServiceEntry, path: string = resolveManifestPath()): void {
-  mkdirSync(dirname(path), { recursive: true });
-  const manifest = readManifest(path);
-  const idx = manifest.services.findIndex((s) => s.name === entry.name);
-  // Merge rather than replace so fields the hub stamps onto the row
-  // (`installDir` from parachute-hub#84, etc.) survive a self-registration
-  // pass. Paraclaw still wins for the fields it owns — port, paths,
-  // version, health — because they spread last.
-  if (idx >= 0) manifest.services[idx] = { ...manifest.services[idx], ...entry };
-  else manifest.services.push(entry);
-  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync(tmp, `${JSON.stringify(manifest, null, 2)}\n`);
-  renameSync(tmp, path);
-}

package/src/web/static-serve.test.ts

@@ -1,255 +0,0 @@
-/**
- * Static-serve mount-strip tests. Mirrors the cases in paraclaw#13:
- *   - mount=""  : behavior unchanged from pre-strip implementation
- *   - mount=/X  : prefix stripped before resolving against dist/
- *   - SPA fallback returns dist/index.html with text/html content-type
- *   - Path traversal still 400s
- *   - Absent dist/ → 503
- *
- * Uses a real http server bound to an ephemeral port + a real dist fixture
- * on disk. Faster than spinning up the full paraclaw server (no DB / auth)
- * but still exercises the actual fs + node http stack — same shape as
- * auth.test.ts.
- */
-import http from 'node:http';
-import type { AddressInfo } from 'node:net';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-
-import { makeServeStatic, normalizeMount } from './static-serve.js';
-
-interface FetchResult {
-  status: number;
-  contentType: string;
-  body: string;
-}
-
-function fetchPath(baseUrl: string, urlPath: string): Promise<FetchResult> {
-  // Use http.request with explicit path so callers can send raw paths like
-  // `/../etc/passwd` without the URL parser normalizing `..` away before the
-  // request goes on the wire — that matters for the path-traversal test.
-  const url = new URL(baseUrl);
-  return new Promise((resolve, reject) => {
-    const req = http.request(
-      {
-        host: url.hostname,
-        port: url.port,
-        method: 'GET',
-        path: urlPath,
-      },
-      (res) => {
-        const chunks: Buffer[] = [];
-        res.on('data', (c) => chunks.push(c as Buffer));
-        res.on('end', () => {
-          resolve({
-            status: res.statusCode ?? 0,
-            contentType: String(res.headers['content-type'] ?? ''),
-            body: Buffer.concat(chunks).toString('utf8'),
-          });
-        });
-      },
-    );
-    req.on('error', reject);
-    req.end();
-  });
-}
-
-function startServer(handler: (req: http.IncomingMessage, res: http.ServerResponse) => void): Promise<{
-  server: http.Server;
-  baseUrl: string;
-}> {
-  return new Promise((resolve) => {
-    const server = http.createServer(handler);
-    server.listen(0, '127.0.0.1', () => {
-      const port = (server.address() as AddressInfo).port;
-      resolve({ server, baseUrl: `http://127.0.0.1:${port}` });
-    });
-  });
-}
-
-function stopServer(server: http.Server): Promise<void> {
-  return new Promise((resolve) => server.close(() => resolve()));
-}
-
-describe('normalizeMount', () => {
-  it('returns empty for empty + slash', () => {
-    expect(normalizeMount('')).toBe('');
-    expect(normalizeMount('/')).toBe('');
-  });
-
-  it('strips trailing slash', () => {
-    expect(normalizeMount('/agent')).toBe('/agent');
-    expect(normalizeMount('/agent/')).toBe('/agent');
-    expect(normalizeMount('/agent///')).toBe('/agent');
-  });
-});
-
-describe('makeServeStatic', () => {
-  let distDir: string;
-
-  beforeEach(() => {
-    distDir = mkdtempSync(join(tmpdir(), 'parachute-agent-static-'));
-    writeFileSync(join(distDir, 'index.html'), '<!doctype html><html><body>shell</body></html>');
-    mkdirSync(join(distDir, 'assets'));
-    writeFileSync(join(distDir, 'assets', 'index-X.js'), 'export const k = 1;');
-    writeFileSync(join(distDir, 'assets', 'index-X.css'), 'body { color: red }');
-  });
-
-  afterEach(() => {
-    rmSync(distDir, { recursive: true, force: true });
-  });
-
-  describe('mount=""', () => {
-    let server: http.Server;
-    let baseUrl: string;
-
-    beforeAll(() => {});
-
-    beforeEach(async () => {
-      const handler = makeServeStatic({ distDir, mount: '' });
-      const ctx = await startServer((req, res) => {
-        const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
-        handler(req, res, url.pathname);
-      });
-      server = ctx.server;
-      baseUrl = ctx.baseUrl;
-    });
-
-    afterEach(async () => {
-      await stopServer(server);
-    });
-
-    it('GET / serves index.html as text/html', async () => {
-      const r = await fetchPath(baseUrl, '/');
-      expect(r.status).toBe(200);
-      expect(r.contentType).toContain('text/html');
-      expect(r.body).toContain('shell');
-    });
-
-    it('GET /assets/index-X.js serves the file as application/javascript', async () => {
-      const r = await fetchPath(baseUrl, '/assets/index-X.js');
-      expect(r.status).toBe(200);
-      expect(r.contentType).toContain('application/javascript');
-      expect(r.body).toBe('export const k = 1;');
-    });
-
-    it('GET /unknown/path SPA-falls-back to index.html', async () => {
-      const r = await fetchPath(baseUrl, '/unknown/path');
-      expect(r.status).toBe(200);
-      expect(r.contentType).toContain('text/html');
-      expect(r.body).toContain('shell');
-    });
-  });
-
-  describe('mount="/agent"', () => {
-    let server: http.Server;
-    let baseUrl: string;
-
-    beforeEach(async () => {
-      const handler = makeServeStatic({ distDir, mount: '/agent' });
-      const ctx = await startServer((req, res) => {
-        const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
-        handler(req, res, url.pathname);
-      });
-      server = ctx.server;
-      baseUrl = ctx.baseUrl;
-    });
-
-    afterEach(async () => {
-      await stopServer(server);
-    });
-
-    it('GET /agent/ serves index.html as text/html (prefix stripped → /)', async () => {
-      const r = await fetchPath(baseUrl, '/agent/');
-      expect(r.status).toBe(200);
-      expect(r.contentType).toContain('text/html');
-      expect(r.body).toContain('shell');
-    });
-
-    it('GET /agent/assets/index-X.js serves the JS bundle correctly (the regression #13 fixed)', async () => {
-      const r = await fetchPath(baseUrl, '/agent/assets/index-X.js');
-      expect(r.status).toBe(200);
-      expect(r.contentType).toContain('application/javascript');
-      expect(r.body).toBe('export const k = 1;');
-    });
-
-    it('GET /agent/assets/index-X.css serves CSS correctly', async () => {
-      const r = await fetchPath(baseUrl, '/agent/assets/index-X.css');
-      expect(r.status).toBe(200);
-      expect(r.contentType).toContain('text/css');
-      expect(r.body).toBe('body { color: red }');
-    });
-
-    it('GET /agent/some/spa/route SPA-falls-back to index.html (BrowserRouter resolves)', async () => {
-      const r = await fetchPath(baseUrl, '/agent/some/spa/route');
-      expect(r.status).toBe(200);
-      expect(r.contentType).toContain('text/html');
-      expect(r.body).toContain('shell');
-    });
-
-    it('GET /assets/index-X.js (no prefix) still serves the file — matches notes-serve behavior', async () => {
-      // Defense-in-depth: paths that don't start with the mount aren't 404'd.
-      // The real frontend never makes these requests (Vite bakes /agent/ into
-      // the bundle's asset URLs), but a direct test from a healthcheck or
-      // local-dev curl shouldn't break — same shape as
-      // parachute-hub/src/notes-serve.ts at paths-without-prefix.
-      const r = await fetchPath(baseUrl, '/assets/index-X.js');
-      expect(r.status).toBe(200);
-      expect(r.contentType).toContain('application/javascript');
-      expect(r.body).toBe('export const k = 1;');
-    });
-
-    it('GET /agent is a SPA route (no trailing slash) → SPA shell', async () => {
-      const r = await fetchPath(baseUrl, '/agent');
-      expect(r.status).toBe(200);
-      expect(r.contentType).toContain('text/html');
-      expect(r.body).toContain('shell');
-    });
-  });
-
-  describe('safety', () => {
-    // The URL constructor in server.ts (and in the http test fixture above)
-    // normalizes `..` away before the handler ever sees the path, so the
-    // `..` guard inside makeServeStatic is defense-in-depth — tested by
-    // calling the handler directly with a synthetic url-path.
-    it('handler called with a path containing `..` → 400 bad path', () => {
-      const handler = makeServeStatic({ distDir, mount: '' });
-      let status = 0;
-      let body = '';
-      const res = {
-        writeHead(s: number) {
-          status = s;
-        },
-        end(chunk?: string) {
-          body = chunk ?? '';
-        },
-      } as unknown as http.ServerResponse;
-      handler({} as http.IncomingMessage, res, '/../etc/passwd');
-      expect(status).toBe(400);
-      expect(body).toContain('bad path');
-    });
-  });
-
-  describe('missing dist', () => {
-    it('returns 503 with a build-instruction body', async () => {
-      const handler = makeServeStatic({
-        distDir: join(tmpdir(), 'paraclaw-does-not-exist-' + Date.now()),
-        mount: '',
-      });
-      const ctx = await startServer((req, res) => {
-        const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
-        handler(req, res, url.pathname);
-      });
-      try {
-        const r = await fetchPath(ctx.baseUrl, '/');
-        expect(r.status).toBe(503);
-        expect(r.body).toContain('UI bundle not found');
-      } finally {
-        await stopServer(ctx.server);
-      }
-    });
-  });
-});

package/src/web/static-serve.ts

@@ -1,104 +0,0 @@
-/**
- * Static-file handler for the built UI bundle, with optional mount-prefix
- * stripping.
- *
- * When parachute-agent is fronted by `parachute expose tailnet` at a path
- * prefix (e.g. `https://<host>/agent/`), tailscale serve forwards the
- * request with the prefix preserved. Combined with a Vite build that bakes
- * the prefix into asset URLs (`VITE_BASE_PATH=/agent/`), the browser asks
- * for `/agent/assets/index-X.js` — which a 1:1 path-to-dist map turns into
- * the non-existent `dist/agent/assets/index-X.js`, falls back to the SPA
- * shell, and ships `text/html` for what should be a JS module. Page never
- * boots.
- *
- * Mirrors `parachute-hub/src/notes-serve.ts:96-115` — strip the mount
- * prefix off the request path before resolving against `dist/`. Standalone
- * parachute-agent (`mount=""`) is unchanged: the strip is a no-op when no
- * prefix is configured.
- */
-import http from 'node:http';
-import fs from 'node:fs';
-import path from 'node:path';
-
-export const MIME_TYPES: Record<string, string> = {
-  '.html': 'text/html; charset=utf-8',
-  '.js': 'application/javascript; charset=utf-8',
-  '.css': 'text/css; charset=utf-8',
-  '.json': 'application/json; charset=utf-8',
-  '.svg': 'image/svg+xml',
-  '.png': 'image/png',
-  '.ico': 'image/x-icon',
-  '.txt': 'text/plain; charset=utf-8',
-};
-
-/**
- * Normalize a mount value to either `""` (no strip) or a prefix without a
- * trailing slash (e.g. `/agent`). `""` and `"/"` both mean "no strip" so
- * standalone deployments at the origin root don't accidentally strip a
- * leading `/`.
- */
-export function normalizeMount(raw: string): string {
-  if (raw === '' || raw === '/') return '';
-  return raw.replace(/\/+$/, '');
-}
-
-export interface StaticServeOpts {
-  distDir: string;
-  /** Mount prefix to strip before resolving against `distDir` (e.g. `/agent`). */
-  mount: string;
-}
-
-/**
- * Build the static-serve handler closure. The returned function has the
- * same shape as the inline handler that previously lived in server.ts —
- * `(req, res, urlPath)` — but resolves through the configured mount + dist.
- *
- * SPA-fallback behavior matches the prior implementation: any path that
- * doesn't resolve to a real file under `dist/` returns `index.html` so
- * BrowserRouter routes work on hard-refresh. The mount-strip only changes
- * the lookup; missing-file fallback is unchanged.
- */
-export function makeServeStatic(opts: StaticServeOpts) {
-  const { distDir, mount } = opts;
-  return function serveStatic(_req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
-    if (!fs.existsSync(distDir)) {
-      res.writeHead(503, { 'content-type': 'text/plain; charset=utf-8' });
-      res.end(
-        'UI bundle not found at ' +
-          distDir +
-          '\n\nIn dev: run `pnpm --filter @parachute-agent/web-ui dev` and open http://localhost:5173/.\n' +
-          'In prod: run `pnpm --filter @parachute-agent/web-ui build` first.',
-      );
-      return;
-    }
-
-    let pathname = urlPath;
-    if (mount && (pathname === mount || pathname.startsWith(`${mount}/`))) {
-      pathname = pathname.slice(mount.length) || '/';
-    }
-
-    let rel = pathname.replace(/^\/+/, '') || 'index.html';
-
-    if (rel.includes('..')) {
-      res.writeHead(400);
-      res.end('bad path');
-      return;
-    }
-
-    let abs = path.join(distDir, rel);
-    if (!abs.startsWith(distDir)) {
-      res.writeHead(403);
-      res.end('forbidden');
-      return;
-    }
-
-    if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) {
-      abs = path.join(distDir, 'index.html');
-    }
-    const ext = path.extname(abs).toLowerCase();
-    const mime = MIME_TYPES[ext] ?? 'application/octet-stream';
-    const stream = fs.createReadStream(abs);
-    res.writeHead(200, { 'content-type': mime });
-    stream.pipe(res);
-  };
-}

package/src/web/telegram-validate.test.ts

@@ -1,116 +0,0 @@
-/**
- * Token validation paths for Telegram. Mirror of discord-validate.test.ts so
- * the same wizard surface can render either result with one error shape.
- */
-import { describe, expect, it } from 'vitest';
-
-import { validateTelegramBotToken } from './telegram-validate.js';
-
-const VALID_TOKEN = '1234567890:ABCdefGhIJklmnopQRsTUvwxyz0123456789';
-
-function fakeFetch(impl: (url: string) => { status?: number; body: unknown }): typeof fetch {
-  return (async (input: string | URL | Request) => {
-    const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
-    const { status = 200, body } = impl(url);
-    return new Response(JSON.stringify(body), {
-      status,
-      headers: { 'content-type': 'application/json' },
-    });
-  }) as typeof fetch;
-}
-
-describe('validateTelegramBotToken', () => {
-  it('rejects an empty token without fetching', async () => {
-    const result = await validateTelegramBotToken('   ', (() => {
-      throw new Error('fetch should not be called');
-    }) as unknown as typeof fetch);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(400);
-      expect(result.error).toMatch(/empty/);
-    }
-  });
-
-  it('rejects a malformed token shape without fetching', async () => {
-    const result = await validateTelegramBotToken('not-a-real-token', (() => {
-      throw new Error('fetch should not be called');
-    }) as unknown as typeof fetch);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(400);
-      expect(result.error).toMatch(/format invalid/);
-    }
-  });
-
-  it('returns identity on success', async () => {
-    const fetchImpl = fakeFetch(() => ({
-      status: 200,
-      body: {
-        ok: true,
-        result: { id: 6037840640, username: 'andy_bot', first_name: 'Andy', is_bot: true },
-      },
-    }));
-    const result = await validateTelegramBotToken(VALID_TOKEN, fetchImpl);
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.identity.id).toBe(6037840640);
-      expect(result.identity.username).toBe('andy_bot');
-      expect(result.identity.firstName).toBe('Andy');
-      expect(result.identity.isBot).toBe(true);
-    }
-  });
-
-  it('rejects when telegram returns ok:false', async () => {
-    const fetchImpl = fakeFetch(() => ({
-      status: 401,
-      body: { ok: false, error_code: 401, description: 'Unauthorized' },
-    }));
-    const result = await validateTelegramBotToken(VALID_TOKEN, fetchImpl);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(401);
-      expect(result.error).toMatch(/rejected token/i);
-    }
-  });
-
-  it('rejects a non-bot account', async () => {
-    const fetchImpl = fakeFetch(() => ({
-      status: 200,
-      body: {
-        ok: true,
-        result: { id: 1, username: 'human', first_name: 'Real Person', is_bot: false },
-      },
-    }));
-    const result = await validateTelegramBotToken(VALID_TOKEN, fetchImpl);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(400);
-      expect(result.error).toMatch(/not a bot/i);
-    }
-  });
-
-  it('returns 502 when telegram is unreachable', async () => {
-    const fetchImpl = (async () => {
-      throw new TypeError('network down');
-    }) as unknown as typeof fetch;
-    const result = await validateTelegramBotToken(VALID_TOKEN, fetchImpl);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(502);
-      expect(result.error).toMatch(/unreachable/);
-    }
-  });
-
-  it('returns 502 on malformed result body', async () => {
-    const fetchImpl = fakeFetch(() => ({
-      status: 200,
-      body: { ok: true, result: {} },
-    }));
-    const result = await validateTelegramBotToken(VALID_TOKEN, fetchImpl);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(502);
-      expect(result.error).toMatch(/malformed/);
-    }
-  });
-});