@nemu.pm/tachiyomi-cli 0.1.0

package/lib/extension-loader.ts

@@ -0,0 +1,163 @@
+import * as fs from "fs";
+import * as path from "path";
+import { installHttpBridge } from "./http";
+
+export interface TachiyomiExports {
+  getManifest(): string;
+  getPopularManga(sourceId: string, page: number): string;
+  getLatestUpdates(sourceId: string, page: number): string;
+  searchManga(sourceId: string, page: number, query: string): string;
+  getMangaDetails(sourceId: string, mangaUrl: string): string;
+  getChapterList(sourceId: string, mangaUrl: string): string;
+  getPageList(sourceId: string, chapterUrl: string): string;
+  getFilterList(sourceId: string): string;
+  fetchImage(sourceId: string, pageUrl: string, pageImageUrl: string): string;
+  getHeaders(sourceId: string): string;
+}
+
+export interface SourceInfo {
+  id: string;
+  name: string;
+  lang: string;
+  baseUrl: string;
+  supportsLatest: boolean;
+}
+
+export interface ExtensionManifest {
+  name: string;
+  pkg: string;
+  version: string;
+  nsfw: boolean;
+  authors?: Array<{
+    name?: string;
+    github?: string;
+    commits: number;
+    firstCommit: string;
+  }>;
+}
+
+export interface LoadedExtension {
+  manifest: ExtensionManifest;
+  exports: TachiyomiExports;
+  sources: SourceInfo[];
+}
+
+export interface MangasPage {
+  mangas: Array<{
+    url: string;
+    title: string;
+    thumbnailUrl?: string;
+    author?: string;
+    artist?: string;
+    description?: string;
+    status?: number;
+    genre?: string[];
+  }>;
+  hasNextPage: boolean;
+}
+
+/** Unwrap Kotlin/JS result format */
+export function unwrapResult<T>(json: string): T {
+  const result = JSON.parse(json) as { ok: boolean; data?: T; error?: any };
+  if (!result.ok) {
+    const errMsg = typeof result.error === "string" ? result.error : JSON.stringify(result.error, null, 2);
+    throw new Error(errMsg || "Unknown error");
+  }
+  return result.data as T;
+}
+
+export interface ExtensionListItem {
+  id: string; // lang/name format
+  name: string;
+  lang: string;
+  isNsfw: boolean;
+}
+
+/** List available built extensions (returns lang/name format) */
+export function listExtensions(outputDir: string): string[] {
+  return listExtensionsWithInfo(outputDir).map((e) => e.id);
+}
+
+/** List available built extensions with manifest info */
+export function listExtensionsWithInfo(outputDir: string): ExtensionListItem[] {
+  if (!fs.existsSync(outputDir)) {
+    return [];
+  }
+
+  const extensions: ExtensionListItem[] = [];
+
+  // Iterate over lang directories
+  for (const lang of fs.readdirSync(outputDir)) {
+    const langDir = path.join(outputDir, lang);
+    if (!fs.statSync(langDir).isDirectory()) continue;
+
+    // Iterate over extension directories within each lang
+    for (const name of fs.readdirSync(langDir)) {
+      const extDir = path.join(langDir, name);
+      const manifestPath = path.join(extDir, "manifest.json");
+      if (fs.statSync(extDir).isDirectory() && fs.existsSync(manifestPath)) {
+        try {
+          const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as ExtensionManifest;
+          extensions.push({
+            id: `${lang}/${name}`,
+            name: manifest.name,
+            lang,
+            isNsfw: manifest.nsfw ?? false,
+          });
+        } catch {
+          extensions.push({
+            id: `${lang}/${name}`,
+            name,
+            lang,
+            isNsfw: false,
+          });
+        }
+      }
+    }
+  }
+
+  return extensions;
+}
+
+/** Load and execute an extension */
+export function loadExtension(outputDir: string, extensionId: string): LoadedExtension {
+  // Install HTTP bridge before loading extension
+  installHttpBridge();
+
+  const extDir = path.join(outputDir, extensionId);
+  const manifestPath = path.join(extDir, "manifest.json");
+  const jsPath = path.join(extDir, "extension.js");
+
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`Extension not found: ${extensionId}\nLooked in: ${extDir}`);
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  const code = fs.readFileSync(jsPath, "utf-8");
+
+  // Execute the extension code
+  const fn = new Function(code);
+  fn();
+
+  // Find the exports in globalThis
+  const g = globalThis as any;
+  let exports: TachiyomiExports | null = null;
+
+  for (const key of Object.keys(g)) {
+    if (g[key]?.tachiyomi?.generated) {
+      exports = g[key].tachiyomi.generated;
+      break;
+    }
+  }
+
+  if (!exports || typeof exports.getManifest !== "function") {
+    throw new Error("Could not find tachiyomi.generated exports");
+  }
+
+  // Get sources from extension
+  const sourcesJson = exports.getManifest();
+  const sources = unwrapResult<SourceInfo[]>(sourcesJson);
+
+  return { manifest, exports, sources };
+}
+

package/lib/http.ts

@@ -0,0 +1,122 @@
+/**
+ * Sync HTTP bridge for Tachiyomi extensions.
+ * Extensions expect synchronous HTTP - we use curl under the hood.
+ */
+
+export function syncHttpRequest(
+  url: string,
+  method: string,
+  headers: Record<string, string>,
+  body: string | null,
+  wantBytes: boolean
+): { status: number; body: string; headers: Record<string, string>; error: string | null } {
+  const args = ["-s", "-S", "-X", method, "-w", "\n%{http_code}", "-D", "-", "-L"];
+
+  for (const [key, value] of Object.entries(headers)) {
+    args.push("-H", `${key}: ${value}`);
+  }
+
+  if (body) {
+    args.push("-d", body);
+  }
+
+  args.push(url);
+
+  const result = Bun.spawnSync(["curl", ...args]);
+  
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim();
+    return {
+      status: 0,
+      body: "",
+      headers: {},
+      error: stderr || `curl failed with exit code ${result.exitCode}`,
+    };
+  }
+  
+  const stdout = result.stdout;
+
+  // Parse headers (until empty line)
+  let headerEndIdx = 0;
+  for (let i = 0; i < stdout.length - 1; i++) {
+    if (stdout[i] === 13 && stdout[i + 1] === 10) {
+      // \r\n
+      if (i + 3 < stdout.length && stdout[i + 2] === 13 && stdout[i + 3] === 10) {
+        headerEndIdx = i + 4;
+        break;
+      }
+    }
+  }
+
+  const headerSection = stdout.slice(0, headerEndIdx).toString();
+  const bodySection = stdout.slice(headerEndIdx);
+
+  // Parse response headers
+  const responseHeaders: Record<string, string> = {};
+  const headerLines = headerSection.split("\r\n");
+  for (const line of headerLines.slice(1)) {
+    // Skip status line
+    const idx = line.indexOf(": ");
+    if (idx > 0) {
+      responseHeaders[line.slice(0, idx).toLowerCase()] = line.slice(idx + 2);
+    }
+  }
+
+  // Find status code from last line (curl -w appends it)
+  // Search backwards for the last newline in the buffer
+  let lastNewlineIdx = bodySection.length - 1;
+  while (lastNewlineIdx >= 0 && bodySection[lastNewlineIdx] !== 10) {
+    lastNewlineIdx--;
+  }
+  
+  const statusCodeStr = bodySection.slice(lastNewlineIdx + 1).toString();
+  const statusCode = parseInt(statusCodeStr) || 200;
+  const bodyBytes = bodySection.slice(0, lastNewlineIdx);
+
+  // If wantBytes, keep as binary and base64 encode
+  let finalBody: string;
+  if (wantBytes) {
+    finalBody = bodyBytes.toString("base64");
+  } else {
+    finalBody = bodyBytes.toString("utf-8");
+  }
+
+  // Check for HTTP errors
+  let error: string | null = null;
+  if (statusCode >= 400) {
+    error = `HTTP ${statusCode}`;
+  }
+
+  return {
+    status: statusCode,
+    body: finalBody,
+    headers: responseHeaders,
+    error,
+  };
+}
+
+/** Install the HTTP bridge into globalThis for Kotlin/JS extensions */
+export function installHttpBridge(): void {
+  (globalThis as any).tachiyomiHttpRequest = (
+    url: string,
+    method: string,
+    headersJson: string,
+    body: string | null,
+    wantBytes: boolean
+  ): { status: number; statusText: string; headersJson: string; body: string; error: string | null } => {
+    if (process.env.DEBUG_HTTP) {
+      console.log(`[HTTP] ${method} ${url}`);
+    }
+    const headers = JSON.parse(headersJson || "{}");
+    const result = syncHttpRequest(url, method, headers, body, wantBytes);
+
+    return {
+      status: result.status,
+      statusText: result.status >= 200 && result.status < 300 ? "OK" : "Error",
+      headersJson: JSON.stringify(result.headers),
+      body: result.body,
+      error: result.error,
+    };
+  };
+}
+

package/lib/output.ts

@@ -0,0 +1,37 @@
+import pc from "picocolors";
+
+export interface OutputOptions {
+  json?: boolean;
+}
+
+export function printJson(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function printHeader(text: string): void {
+  console.log(pc.bold(pc.cyan(`\n=== ${text} ===\n`)));
+}
+
+export function printField(label: string, value: string | number | boolean | undefined): void {
+  if (value !== undefined) {
+    console.log(`${pc.dim(label + ":")} ${value}`);
+  }
+}
+
+export function printListItem(text: string, indent = 0): void {
+  const prefix = "  ".repeat(indent);
+  console.log(`${prefix}${pc.yellow("•")} ${text}`);
+}
+
+export function printError(message: string): void {
+  console.error(pc.red(`Error: ${message}`));
+}
+
+export function printSuccess(message: string): void {
+  console.log(pc.green(`✓ ${message}`));
+}
+
+export function printWarning(message: string): void {
+  console.log(pc.yellow(`⚠ ${message}`));
+}
+

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@nemu.pm/tachiyomi-cli",
+  "version": "0.1.0",
+  "description": "CLI for testing and exploring Tachiyomi extensions (requires bun)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nemu-pm/tachiyomi-js.git",
+    "directory": "cli"
+  },
+  "homepage": "https://github.com/nemu-pm/tachiyomi-js#readme",
+  "type": "module",
+  "bin": {
+    "tachiyomi": "./bin.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.1.0",
+    "@stricli/core": "^1.2.4",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^22.19.3",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "tachiyomi",
+    "manga",
+    "extension",
+    "cli",
+    "bun"
+  ],
+  "license": "MIT"
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "types": ["bun-types", "node"]
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules"]
+}
+