@mindtnv/todoist-cli 0.3.0 → 0.4.0

package/dist/index.js

@@ -657,66 +657,59 @@ function createPaletteRegistry() {
 }
 
 // src/plugins/storage.ts
-import { Database } from "bun:sqlite";
-import { mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { mkdirSync as mkdirSync3, existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { join as join3 } from "path";
+function loadJson(path, fallback) {
+  if (!existsSync3(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function saveJson(path, data) {
+  writeFileSync3(path, JSON.stringify(data, null, 2) + `
+`);
+}
 function createPluginStorage(dataDir) {
   if (!existsSync3(dataDir)) {
     mkdirSync3(dataDir, { recursive: true });
   }
-  const dbPath = join3(dataDir, "data.db");
-  const db = new Database(dbPath);
-  db.run("CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY, value TEXT)");
-  db.run("CREATE TABLE IF NOT EXISTS task_data (task_id TEXT, key TEXT, value TEXT, PRIMARY KEY (task_id, key))");
-  const getStmt = db.prepare("SELECT value FROM kv WHERE key = ?");
-  const setStmt = db.prepare("INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)");
-  const delStmt = db.prepare("DELETE FROM kv WHERE key = ?");
-  const listStmt = db.prepare("SELECT key FROM kv WHERE key LIKE ? ESCAPE '\\'");
-  const getTaskStmt = db.prepare("SELECT value FROM task_data WHERE task_id = ? AND key = ?");
-  const setTaskStmt = db.prepare("INSERT OR REPLACE INTO task_data (task_id, key, value) VALUES (?, ?, ?)");
+  const kvPath = join3(dataDir, "kv.json");
+  const taskDataPath = join3(dataDir, "task-data.json");
+  let kv = loadJson(kvPath, {});
+  let taskData = loadJson(taskDataPath, {});
   return {
     async get(key) {
-      const row = getStmt.get(key);
-      if (!row)
-        return null;
-      try {
-        return JSON.parse(row.value);
-      } catch {
-        console.warn("[plugin-storage] Corrupted data for key:", key);
-        return null;
-      }
+      const value = kv[key];
+      return value !== undefined ? value : null;
     },
     async set(key, value) {
-      const serialized = JSON.stringify(value);
-      setStmt.run(key, serialized);
+      kv[key] = value;
+      saveJson(kvPath, kv);
     },
     async delete(key) {
-      delStmt.run(key);
+      delete kv[key];
+      saveJson(kvPath, kv);
     },
     async list(prefix) {
-      const escapedPrefix = prefix ? prefix.replace(/[%_\\]/g, (ch) => `\\${ch}`) : "";
-      const pattern = prefix ? `${escapedPrefix}%` : "%";
-      const rows = listStmt.all(pattern);
-      return rows.map((r) => r.key);
+      const keys = Object.keys(kv);
+      if (!prefix)
+        return keys;
+      return keys.filter((k) => k.startsWith(prefix));
     },
     async getTaskData(taskId, key) {
-      const row = getTaskStmt.get(taskId, key);
-      if (!row)
-        return null;
-      try {
-        return JSON.parse(row.value);
-      } catch {
-        console.warn("[plugin-storage] Corrupted data for key:", `${taskId}:${key}`);
-        return null;
-      }
+      const value = taskData[taskId]?.[key];
+      return value !== undefined ? value : null;
     },
     async setTaskData(taskId, key, value) {
-      const serialized = JSON.stringify(value);
-      setTaskStmt.run(taskId, key, serialized);
+      if (!taskData[taskId])
+        taskData[taskId] = {};
+      taskData[taskId][key] = value;
+      saveJson(taskDataPath, taskData);
     },
-    close() {
-      db.close();
-    }
+    close() {}
   };
 }
 var init_storage = () => {};
@@ -795,7 +788,7 @@ var init_api_proxy = __esm(() => {
 
 // src/plugins/loader.ts
 import { join as join4 } from "path";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 function createLogger(pluginName) {
   return {
@@ -843,7 +836,7 @@ async function loadPlugins(hooks, views, extensions, palette) {
       let manifest = null;
       if (existsSync4(manifestPath)) {
         try {
-          manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+          manifest = JSON.parse(readFileSync4(manifestPath, "utf-8"));
         } catch (parseErr) {
           console.warn(`[plugins] Invalid plugin.json for "${name}":`, parseErr instanceof Error ? parseErr.message : parseErr);
         }
@@ -8482,13 +8475,13 @@ Examples:
       }
       let description = opts.description;
       if (opts.editor) {
-        const { writeFileSync: writeFileSync3, readFileSync: readFileSync4 } = await import("node:fs");
+        const { writeFileSync: writeFileSync4, readFileSync: readFileSync5 } = await import("node:fs");
         const { spawnSync } = await import("node:child_process");
         const tmpFile = `/tmp/todoist-desc-${Date.now()}.md`;
-        writeFileSync3(tmpFile, description ?? "");
+        writeFileSync4(tmpFile, description ?? "");
         const editor = process.env.EDITOR || process.env.VISUAL || "vi";
         spawnSync(editor, [tmpFile], { stdio: "inherit" });
-        description = readFileSync4(tmpFile, "utf-8");
+        description = readFileSync5(tmpFile, "utf-8");
         if (description.trim() === "")
           description = undefined;
       }
@@ -9465,12 +9458,12 @@ function registerSectionCommand(program) {
 
 // src/cli/completion.ts
 init_config();
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { join as join5 } from "path";
 import chalk18 from "chalk";
 var COMPLETION_CACHE_PATH = join5(CONFIG_DIR, ".completion-cache.json");
 function saveCompletionCache(cache) {
-  writeFileSync3(COMPLETION_CACHE_PATH, JSON.stringify(cache, null, 2), "utf-8");
+  writeFileSync4(COMPLETION_CACHE_PATH, JSON.stringify(cache, null, 2), "utf-8");
 }
 var BASH_COMPLETION = `#!/usr/bin/env bash
 # todoist CLI bash completion
@@ -10223,223 +10216,589 @@ function registerFilterCommand(program) {
 // src/cli/plugin.ts
 import chalk25 from "chalk";
 
-// src/plugins/installer.ts
+// src/plugins/marketplace.ts
 init_config();
-import { join as join6, resolve } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync, symlinkSync, lstatSync } from "fs";
+import { join as join6 } from "path";
 import { homedir as homedir4 } from "os";
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync6,
+  rmSync,
+  cpSync
+} from "fs";
 import { execSync } from "child_process";
-var PLUGINS_DIR2 = join6(homedir4(), ".config", "todoist-cli", "plugins");
-function ensurePluginsDir() {
-  if (!existsSync6(PLUGINS_DIR2)) {
-    mkdirSync4(PLUGINS_DIR2, { recursive: true });
-  }
+var CONFIG_DIR3 = join6(homedir4(), ".config", "todoist-cli");
+var MARKETPLACE_CACHE_DIR = join6(CONFIG_DIR3, "marketplace-cache");
+var PLUGINS_DIR2 = join6(CONFIG_DIR3, "plugins");
+var DEFAULT_MARKETPLACE = "github:mindtnv/todoist-cli";
+var DEFAULT_MARKETPLACE_NAME = "todoist-cli-official";
+function ensureDir(dir) {
+  if (!existsSync6(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+}
+function parseGitHubSource(source) {
+  if (!source.startsWith("github:"))
+    return null;
+  const parts = source.replace("github:", "").split("/");
+  if (parts.length < 2 || !parts[0] || !parts[1])
+    return null;
+  return { user: parts[0], repo: parts[1] };
 }
-function derivePluginName(source) {
+function deriveNameFromSource(source) {
   if (source.startsWith("github:")) {
     const parts = source.replace("github:", "").split("/");
     return parts[parts.length - 1] ?? source;
   }
-  if (source.startsWith("npm:")) {
-    return source.replace("npm:", "").replace(/^@[^/]+\//, "");
+  try {
+    const url = new URL(source);
+    const segments = url.pathname.split("/").filter(Boolean);
+    return segments[segments.length - 1] ?? source;
+  } catch {
+    return source.split("/").pop() ?? source;
   }
-  return source.split("/").pop() ?? source;
 }
-async function installPlugin(source) {
-  ensurePluginsDir();
-  let name = derivePluginName(source);
-  const targetDir = join6(PLUGINS_DIR2, name);
-  if (existsSync6(targetDir)) {
-    throw new Error(`Plugin "${name}" is already installed. Use "todoist plugin remove ${name}" first.`);
+function isExternalSource(source) {
+  return typeof source === "object" && source !== null && "type" in source;
+}
+function getRegisteredMarketplaces() {
+  const config = getConfig();
+  const marketplaces = [];
+  marketplaces.push({
+    name: DEFAULT_MARKETPLACE_NAME,
+    source: DEFAULT_MARKETPLACE,
+    autoUpdate: true
+  });
+  const configMarketplaces = config.marketplaces;
+  if (configMarketplaces) {
+    for (const [name, entry] of Object.entries(configMarketplaces)) {
+      if (name === DEFAULT_MARKETPLACE_NAME)
+        continue;
+      marketplaces.push({
+        name,
+        source: entry.source ?? "",
+        autoUpdate: entry.autoUpdate ?? true
+      });
+    }
   }
-  if (source.startsWith("github:")) {
-    const repo = source.replace("github:", "");
-    execSync(`git clone https://github.com/${repo}.git "${targetDir}"`, { stdio: "pipe" });
-  } else if (source.startsWith("npm:")) {
-    const pkg = source.replace("npm:", "");
-    mkdirSync4(targetDir, { recursive: true });
-    execSync(`cd "${targetDir}" && npm init -y && npm install ${pkg}`, { stdio: "pipe" });
+  return marketplaces;
+}
+function addMarketplace(source) {
+  const name = deriveNameFromSource(source);
+  if (name === DEFAULT_MARKETPLACE_NAME) {
+    throw new Error(`Cannot add marketplace with reserved name "${DEFAULT_MARKETPLACE_NAME}".`);
+  }
+  const config = getConfig();
+  const rawConfig = config;
+  if (!rawConfig.marketplaces) {
+    rawConfig.marketplaces = {};
+  }
+  const marketplaces = rawConfig.marketplaces;
+  marketplaces[name] = { source, autoUpdate: true };
+  saveConfig(config);
+  return name;
+}
+function removeMarketplace(name) {
+  if (name === DEFAULT_MARKETPLACE_NAME) {
+    throw new Error(`Cannot remove the default marketplace "${DEFAULT_MARKETPLACE_NAME}".`);
+  }
+  const config = getConfig();
+  const rawConfig = config;
+  const marketplaces = rawConfig.marketplaces;
+  if (!marketplaces || !(name in marketplaces)) {
+    throw new Error(`Marketplace "${name}" is not registered.`);
+  }
+  delete marketplaces[name];
+  saveConfig(config);
+  const cacheDir = join6(MARKETPLACE_CACHE_DIR, name);
+  if (existsSync6(cacheDir)) {
+    rmSync(cacheDir, { recursive: true, force: true });
+  }
+}
+async function fetchMarketplaceManifest(config) {
+  ensureDir(MARKETPLACE_CACHE_DIR);
+  const github = parseGitHubSource(config.source);
+  if (github) {
+    const cacheDir = join6(MARKETPLACE_CACHE_DIR, config.name);
+    if (existsSync6(cacheDir)) {
+      try {
+        execSync(`git -C "${cacheDir}" pull`, { stdio: "pipe" });
+      } catch {}
+    } else {
+      execSync(`git clone https://github.com/${github.user}/${github.repo}.git "${cacheDir}"`, { stdio: "pipe" });
+    }
+    const manifestPath2 = join6(cacheDir, "marketplace.json");
+    if (!existsSync6(manifestPath2)) {
+      throw new Error(`Marketplace "${config.name}" does not contain a marketplace.json file.`);
+    }
+    const raw2 = readFileSync6(manifestPath2, "utf-8");
+    return JSON.parse(raw2);
+  }
+  if (config.source.startsWith("http://") || config.source.startsWith("https://")) {
+    const response = await fetch(config.source);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch marketplace manifest from ${config.source}: ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  const manifestPath = join6(config.source, "marketplace.json");
+  if (!existsSync6(manifestPath)) {
+    throw new Error(`Marketplace at "${config.source}" does not contain a marketplace.json file.`);
+  }
+  const raw = readFileSync6(manifestPath, "utf-8");
+  return JSON.parse(raw);
+}
+async function discoverPlugins() {
+  const marketplaces = getRegisteredMarketplaces();
+  const discovered = [];
+  const config = getConfig();
+  const installedPlugins = config.plugins ?? {};
+  for (const marketplace of marketplaces) {
+    try {
+      const manifest = await fetchMarketplaceManifest(marketplace);
+      for (const plugin of manifest.plugins) {
+        const isInstalled = plugin.name in installedPlugins;
+        const pluginConfig = installedPlugins[plugin.name];
+        const isEnabled = isInstalled ? pluginConfig?.enabled !== false : false;
+        discovered.push({
+          ...plugin,
+          marketplace: marketplace.name,
+          installed: isInstalled,
+          enabled: isEnabled
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return discovered;
+}
+async function installPlugin(pluginName, marketplaceName) {
+  ensureDir(PLUGINS_DIR2);
+  const allPlugins = await discoverPlugins();
+  let candidates = allPlugins.filter((p) => p.name === pluginName);
+  if (marketplaceName) {
+    candidates = candidates.filter((p) => p.marketplace === marketplaceName);
+  }
+  if (candidates.length === 0) {
+    throw new Error(`Plugin "${pluginName}" not found${marketplaceName ? ` in marketplace "${marketplaceName}"` : ""}.`);
+  }
+  const plugin = candidates[0];
+  if (plugin.installed) {
+    throw new Error(`Plugin "${pluginName}" is already installed. Use "todoist plugin remove ${pluginName}" first.`);
+  }
+  const targetDir = join6(PLUGINS_DIR2, pluginName);
+  if (isExternalSource(plugin.source)) {
+    resolveExternalSource(plugin.source, targetDir);
   } else {
-    const resolvedPath = resolve(process.cwd(), source);
-    if (!existsSync6(resolvedPath))
-      throw new Error(`Local path not found: ${resolvedPath}`);
-    symlinkSync(resolvedPath, targetDir, "dir");
+    const source = plugin.source;
+    if (source.startsWith("./") || source.startsWith("../")) {
+      const cacheDir = join6(MARKETPLACE_CACHE_DIR, plugin.marketplace);
+      const sourcePath = join6(cacheDir, source);
+      if (!existsSync6(sourcePath)) {
+        throw new Error(`Plugin source path not found: ${sourcePath}`);
+      }
+      ensureDir(targetDir);
+      cpSync(sourcePath, targetDir, { recursive: true });
+    } else if (source.startsWith("github:")) {
+      const github = parseGitHubSource(source);
+      if (!github)
+        throw new Error(`Invalid GitHub source: ${source}`);
+      execSync(`git clone https://github.com/${github.user}/${github.repo}.git "${targetDir}"`, { stdio: "pipe" });
+    } else {
+      if (!existsSync6(source)) {
+        throw new Error(`Plugin source path not found: ${source}`);
+      }
+      ensureDir(targetDir);
+      cpSync(source, targetDir, { recursive: true });
+    }
   }
-  const isSymlink = lstatSync(targetDir).isSymbolicLink();
-  if (!isSymlink && existsSync6(join6(targetDir, "package.json"))) {
+  if (existsSync6(join6(targetDir, "package.json"))) {
     try {
       execSync(`cd "${targetDir}" && bun install`, { stdio: "pipe" });
     } catch {
-      execSync(`cd "${targetDir}" && npm install`, { stdio: "pipe" });
+      try {
+        execSync(`cd "${targetDir}" && npm install`, { stdio: "pipe" });
+      } catch {}
     }
   }
-  const manifestPath = join6(targetDir, "plugin.json");
-  let manifest = null;
-  if (existsSync6(manifestPath)) {
-    manifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
-    name = manifest.name;
-  }
-  setPluginEntry(name, { source });
+  setPluginEntry(pluginName, {
+    source: `${pluginName}@${plugin.marketplace}`,
+    enabled: true
+  });
   return {
-    name,
-    version: manifest?.version ?? "unknown",
-    description: manifest?.description,
-    permissions: manifest?.permissions
+    name: pluginName,
+    version: plugin.version ?? "unknown",
+    marketplace: plugin.marketplace,
+    description: plugin.description
   };
 }
+function resolveExternalSource(source, targetDir) {
+  switch (source.type) {
+    case "github": {
+      if (!source.repo)
+        throw new Error("GitHub source requires a 'repo' field.");
+      const ref = source.ref ? ` --branch ${source.ref}` : "";
+      execSync(`git clone https://github.com/${source.repo}.git${ref} "${targetDir}"`, { stdio: "pipe" });
+      if (source.sha) {
+        execSync(`git -C "${targetDir}" checkout ${source.sha}`, {
+          stdio: "pipe"
+        });
+      }
+      break;
+    }
+    case "git": {
+      if (!source.url)
+        throw new Error("Git source requires a 'url' field.");
+      const ref = source.ref ? ` --branch ${source.ref}` : "";
+      execSync(`git clone ${source.url}${ref} "${targetDir}"`, {
+        stdio: "pipe"
+      });
+      if (source.sha) {
+        execSync(`git -C "${targetDir}" checkout ${source.sha}`, {
+          stdio: "pipe"
+        });
+      }
+      break;
+    }
+    case "npm": {
+      if (!source.package)
+        throw new Error("npm source requires a 'package' field.");
+      mkdirSync4(targetDir, { recursive: true });
+      execSync(`cd "${targetDir}" && npm init -y && npm install ${source.package}`, { stdio: "pipe" });
+      break;
+    }
+    default:
+      throw new Error(`Unknown source type: ${source.type}`);
+  }
+}
 function removePlugin(name) {
   const targetDir = join6(PLUGINS_DIR2, name);
-  if (!existsSync6(targetDir)) {
-    throw new Error(`Plugin "${name}" is not installed.`);
-  }
-  if (lstatSync(targetDir).isSymbolicLink()) {
-    rmSync(targetDir);
-  } else {
+  if (existsSync6(targetDir)) {
     rmSync(targetDir, { recursive: true, force: true });
   }
   removePluginEntry(name);
 }
-function enablePlugin(name) {
+async function updatePlugin(name) {
   const config = getConfig();
   const plugins = config.plugins;
   if (!plugins?.[name]) {
     throw new Error(`Plugin "${name}" is not installed.`);
   }
-  const { enabled, ...rest } = plugins[name];
-  setPluginEntry(name, rest);
-}
-function disablePlugin(name) {
-  const config = getConfig();
-  const plugins = config.plugins;
-  if (!plugins?.[name]) {
-    throw new Error(`Plugin "${name}" is not installed.`);
+  const pluginEntry = plugins[name];
+  const sourceStr = pluginEntry.source;
+  if (!sourceStr) {
+    return { name, updated: false, message: "No source information found" };
   }
-  setPluginEntry(name, { ...plugins[name], enabled: false });
-}
-function updatePlugin(name) {
-  const config = getConfig();
-  const plugins = config.plugins;
-  if (!plugins?.[name]) {
-    throw new Error(`Plugin "${name}" is not installed.`);
+  const atIndex = sourceStr.lastIndexOf("@");
+  const marketplaceName = atIndex > 0 ? sourceStr.substring(atIndex + 1) : undefined;
+  if (!marketplaceName) {
+    return { name, updated: false, message: "Cannot determine marketplace for plugin" };
   }
-  const targetDir = join6(PLUGINS_DIR2, name);
-  if (!existsSync6(targetDir)) {
-    throw new Error(`Plugin directory not found for "${name}".`);
+  await refreshMarketplaceCache(marketplaceName);
+  const marketplaces = getRegisteredMarketplaces();
+  const marketplace = marketplaces.find((m) => m.name === marketplaceName);
+  if (!marketplace) {
+    return { name, updated: false, message: `Marketplace "${marketplaceName}" not found` };
   }
-  const source = plugins[name].source;
-  const isSymlink = lstatSync(targetDir).isSymbolicLink();
-  if (isSymlink) {
-    return { name, updated: false, message: "Local symlink — already up to date" };
+  let manifest;
+  try {
+    manifest = await fetchMarketplaceManifest(marketplace);
+  } catch {
+    return { name, updated: false, message: `Failed to fetch marketplace "${marketplaceName}"` };
   }
-  if (source.startsWith("github:")) {
-    execSync(`cd "${targetDir}" && git pull`, { stdio: "pipe" });
-    if (existsSync6(join6(targetDir, "package.json"))) {
-      try {
-        execSync(`cd "${targetDir}" && bun install`, { stdio: "pipe" });
-      } catch {
-        execSync(`cd "${targetDir}" && npm install`, { stdio: "pipe" });
+  const pluginManifest = manifest.plugins.find((p) => p.name === name);
+  if (!pluginManifest) {
+    return { name, updated: false, message: `Plugin "${name}" no longer in marketplace` };
+  }
+  const oldVersion = pluginEntry.version ?? "unknown";
+  const newVersion = pluginManifest.version ?? "unknown";
+  const targetDir = join6(PLUGINS_DIR2, name);
+  if (isExternalSource(pluginManifest.source)) {
+    if (pluginManifest.source.type === "github" && existsSync6(join6(targetDir, ".git"))) {
+      execSync(`git -C "${targetDir}" pull`, { stdio: "pipe" });
+    } else {
+      if (existsSync6(targetDir)) {
+        rmSync(targetDir, { recursive: true, force: true });
+      }
+      resolveExternalSource(pluginManifest.source, targetDir);
+    }
+  } else {
+    const source = pluginManifest.source;
+    if (source.startsWith("./") || source.startsWith("../")) {
+      const cacheDir = join6(MARKETPLACE_CACHE_DIR, marketplaceName);
+      const sourcePath = join6(cacheDir, source);
+      if (existsSync6(targetDir)) {
+        rmSync(targetDir, { recursive: true, force: true });
       }
+      ensureDir(targetDir);
+      cpSync(sourcePath, targetDir, { recursive: true });
+    } else if (existsSync6(join6(targetDir, ".git"))) {
+      execSync(`git -C "${targetDir}" pull`, { stdio: "pipe" });
     }
-    return { name, updated: true, message: "Pulled latest from git" };
   }
-  if (source.startsWith("npm:")) {
-    const pkg = source.replace("npm:", "");
-    execSync(`cd "${targetDir}" && npm update ${pkg}`, { stdio: "pipe" });
-    return { name, updated: true, message: "Updated npm package" };
+  if (existsSync6(join6(targetDir, "package.json"))) {
+    try {
+      execSync(`cd "${targetDir}" && bun install`, { stdio: "pipe" });
+    } catch {
+      try {
+        execSync(`cd "${targetDir}" && npm install`, { stdio: "pipe" });
+      } catch {}
+    }
   }
-  return { name, updated: false, message: "Local plugin — update manually" };
+  setPluginEntry(name, {
+    ...pluginEntry,
+    version: newVersion
+  });
+  const updated = oldVersion !== newVersion;
+  return {
+    name,
+    updated,
+    oldVersion,
+    newVersion,
+    message: updated ? `Updated from ${oldVersion} to ${newVersion}` : "Already at latest version"
+  };
 }
-function listPlugins() {
+async function updateAllPlugins() {
   const config = getConfig();
   const plugins = config.plugins;
   if (!plugins)
     return [];
-  return Object.entries(plugins).map(([name, cfg]) => ({
-    name,
-    source: cfg.source,
-    enabled: cfg.enabled !== false
-  }));
+  const results = [];
+  for (const name of Object.keys(plugins)) {
+    try {
+      const result = await updatePlugin(name);
+      results.push(result);
+    } catch (err) {
+      results.push({
+        name,
+        updated: false,
+        message: err instanceof Error ? err.message : "Unknown error"
+      });
+    }
+  }
+  return results;
+}
+async function refreshMarketplaceCache(name) {
+  const marketplaces = getRegisteredMarketplaces();
+  const targets = name ? marketplaces.filter((m) => m.name === name) : marketplaces;
+  for (const marketplace of targets) {
+    const github = parseGitHubSource(marketplace.source);
+    if (!github)
+      continue;
+    const cacheDir = join6(MARKETPLACE_CACHE_DIR, marketplace.name);
+    if (existsSync6(cacheDir)) {
+      try {
+        execSync(`git -C "${cacheDir}" pull`, { stdio: "pipe" });
+      } catch {}
+    } else {
+      try {
+        execSync(`git clone https://github.com/${github.user}/${github.repo}.git "${cacheDir}"`, { stdio: "pipe" });
+      } catch {}
+    }
+  }
+}
+function enablePlugin(name) {
+  const config = getConfig();
+  const plugins = config.plugins;
+  if (!plugins?.[name]) {
+    throw new Error(`Plugin "${name}" is not installed.`);
+  }
+  const entry = plugins[name];
+  const { enabled: _enabled, ...rest } = entry;
+  setPluginEntry(name, rest);
+}
+function disablePlugin(name) {
+  const config = getConfig();
+  const plugins = config.plugins;
+  if (!plugins?.[name]) {
+    throw new Error(`Plugin "${name}" is not installed.`);
+  }
+  setPluginEntry(name, { ...plugins[name], enabled: false });
 }
 
 // src/cli/plugin.ts
+init_config();
 function registerPluginCommand(program) {
-  const plugin = program.command("plugin").description("Manage plugins");
-  plugin.command("add").description("Install a plugin (github:user/repo, npm:package, or local path)").argument("<source>", "Plugin source").action(async (source) => {
+  const plugin = program.command("plugin").description("Manage plugins and marketplaces");
+  plugin.command("list").description("List installed plugins").action(() => {
+    try {
+      const config = getConfig();
+      const plugins = config.plugins;
+      if (!plugins || Object.keys(plugins).length === 0) {
+        console.log(chalk25.dim("No plugins installed."));
+        console.log(chalk25.dim("Discover plugins with: todoist plugin discover"));
+        return;
+      }
+      console.log(chalk25.bold("Installed Plugins"));
+      console.log("");
+      for (const [name, entry] of Object.entries(plugins)) {
+        const isEnabled = entry.enabled !== false;
+        const status = isEnabled ? chalk25.green("●") : chalk25.yellow("○");
+        const statusLabel = isEnabled ? chalk25.green("enabled") : chalk25.yellow("disabled");
+        const version = entry.version ?? "unknown";
+        const source = entry.source ?? "";
+        console.log(`  ${status} ${chalk25.bold(name)} ${chalk25.cyan("v" + version)} ${statusLabel} ${chalk25.dim(source)}`);
+      }
+    } catch (err) {
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+  });
+  plugin.command("discover").description("Browse available plugins from all marketplaces").action(async () => {
     try {
-      console.log(chalk25.dim(`Installing plugin from ${source}...`));
-      const result = await installPlugin(source);
-      console.log(chalk25.green(`✓ Installed ${result.name} v${result.version}`));
+      console.log(chalk25.dim("Fetching plugins from marketplaces..."));
+      const discovered = await discoverPlugins();
+      if (discovered.length === 0) {
+        console.log(chalk25.dim("No plugins found in any marketplace."));
+        return;
+      }
+      const grouped = new Map;
+      for (const plugin2 of discovered) {
+        const group = grouped.get(plugin2.marketplace) ?? [];
+        group.push(plugin2);
+        grouped.set(plugin2.marketplace, group);
+      }
+      for (const [marketplace2, plugins] of grouped) {
+        console.log("");
+        console.log(chalk25.bold.underline(marketplace2));
+        console.log("");
+        for (const p of plugins) {
+          let indicator;
+          if (p.installed && p.enabled) {
+            indicator = chalk25.green("●");
+          } else if (p.installed && !p.enabled) {
+            indicator = chalk25.yellow("◐");
+          } else {
+            indicator = chalk25.dim("○");
+          }
+          const version = p.version ? chalk25.cyan("v" + p.version) : "";
+          const description = p.description ? chalk25.dim(p.description) : "";
+          console.log(`  ${indicator} ${chalk25.bold(p.name)} ${version} ${description}`);
+        }
+      }
+    } catch (err) {
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+  });
+  plugin.command("install").description("Install a plugin (optionally name@marketplace)").argument("<name>", "Plugin name (or name@marketplace)").action(async (nameArg) => {
+    try {
+      let pluginName = nameArg;
+      let marketplaceName;
+      const atIndex = nameArg.lastIndexOf("@");
+      if (atIndex > 0) {
+        pluginName = nameArg.substring(0, atIndex);
+        marketplaceName = nameArg.substring(atIndex + 1);
+      }
+      console.log(chalk25.dim(`Installing plugin "${pluginName}"...`));
+      const result = await installPlugin(pluginName, marketplaceName);
+      console.log(chalk25.green(`Installed ${result.name} v${result.version} from ${result.marketplace}`));
       if (result.description) {
         console.log(chalk25.dim(`  ${result.description}`));
       }
-      if (result.permissions?.length) {
-        console.log(chalk25.dim(`  Permissions: ${result.permissions.join(", ")}`));
-      }
     } catch (err) {
-      console.error(chalk25.red(`Failed to install: ${err instanceof Error ? err.message : err}`));
+      console.error(chalk25.red(`Failed to install: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
   });
   plugin.command("remove").description("Remove an installed plugin").argument("<name>", "Plugin name").action((name) => {
     try {
       removePlugin(name);
-      console.log(chalk25.green(`✓ Removed ${name}`));
+      console.log(chalk25.green(`Removed ${name}`));
     } catch (err) {
-      console.error(chalk25.red(err instanceof Error ? err.message : String(err)));
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
   });
-  plugin.command("list").description("List installed plugins").action(() => {
-    const plugins = listPlugins();
-    if (plugins.length === 0) {
-      console.log(chalk25.dim("No plugins installed."));
-      console.log(chalk25.dim("Install one with: todoist plugin add github:user/repo"));
-      return;
-    }
-    for (const p of plugins) {
-      const status = p.enabled ? chalk25.green("●") : chalk25.red("○");
-      console.log(`  ${status} ${chalk25.bold(p.name)} ${chalk25.dim(`(${p.source})`)}`);
+  plugin.command("update").description("Update a specific plugin or all plugins").argument("[name]", "Plugin name (omit to update all)").action(async (name) => {
+    try {
+      if (name) {
+        const result = await updatePlugin(name);
+        if (result.updated) {
+          console.log(chalk25.green(`${result.name}: ${result.message}`));
+        } else {
+          console.log(chalk25.dim(`${result.name}: ${result.message}`));
+        }
+      } else {
+        console.log(chalk25.dim("Updating all plugins..."));
+        const results = await updateAllPlugins();
+        if (results.length === 0) {
+          console.log(chalk25.dim("No plugins installed."));
+          return;
+        }
+        for (const result of results) {
+          if (result.updated) {
+            console.log(chalk25.green(`  ${result.name}: ${result.message}`));
+          } else {
+            console.log(chalk25.dim(`  ${result.name}: ${result.message}`));
+          }
+        }
+      }
+    } catch (err) {
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
     }
   });
   plugin.command("enable").description("Enable a disabled plugin").argument("<name>", "Plugin name").action((name) => {
     try {
       enablePlugin(name);
-      console.log(chalk25.green(`✓ Enabled ${name}`));
+      console.log(chalk25.green(`Enabled ${name}`));
     } catch (err) {
-      console.error(chalk25.red(err instanceof Error ? err.message : String(err)));
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
   });
   plugin.command("disable").description("Disable a plugin without removing it").argument("<name>", "Plugin name").action((name) => {
     try {
       disablePlugin(name);
-      console.log(chalk25.yellow(`○ Disabled ${name}`));
+      console.log(chalk25.yellow(`Disabled ${name}`));
     } catch (err) {
-      console.error(chalk25.red(err instanceof Error ? err.message : String(err)));
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
   });
-  plugin.command("update").description("Update a plugin (or all plugins)").argument("[name]", "Plugin name (omit to update all)").action((name) => {
+  const marketplace = plugin.command("marketplace").description("Manage plugin marketplaces");
+  marketplace.command("list").description("List registered marketplaces").action(() => {
     try {
-      const plugins = name ? [{ name }] : listPlugins();
-      if (plugins.length === 0) {
-        console.log(chalk25.dim("No plugins installed."));
-        return;
-      }
-      for (const p of plugins) {
-        try {
-          const result = updatePlugin(p.name);
-          if (result.updated) {
-            console.log(chalk25.green(`✓ ${result.name}: ${result.message}`));
-          } else {
-            console.log(chalk25.dim(`  ${result.name}: ${result.message}`));
-          }
-        } catch (err) {
-          console.error(chalk25.red(`✗ ${p.name}: ${err instanceof Error ? err.message : err}`));
-        }
+      const marketplaces = getRegisteredMarketplaces();
+      console.log(chalk25.bold("Registered Marketplaces"));
+      console.log("");
+      for (const m of marketplaces) {
+        const autoUpdate = m.autoUpdate ? chalk25.green("auto-update") : chalk25.dim("manual");
+        console.log(`  ${chalk25.bold(m.name)} ${chalk25.dim(m.source)} ${autoUpdate}`);
       }
     } catch (err) {
-      console.error(chalk25.red(err instanceof Error ? err.message : String(err)));
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+  });
+  marketplace.command("add").description("Add a marketplace (e.g. github:user/repo)").argument("<source>", "Marketplace source (github:user/repo)").action((source) => {
+    try {
+      const name = addMarketplace(source);
+      console.log(chalk25.green(`Added marketplace "${name}" from ${source}`));
+    } catch (err) {
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+  });
+  marketplace.command("remove").description("Remove a registered marketplace").argument("<name>", "Marketplace name").action((name) => {
+    try {
+      removeMarketplace(name);
+      console.log(chalk25.green(`Removed marketplace "${name}"`));
+    } catch (err) {
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+  });
+  marketplace.command("refresh").description("Refresh marketplace cache").argument("[name]", "Marketplace name (omit to refresh all)").action(async (name) => {
+    try {
+      console.log(chalk25.dim(`Refreshing ${name ? `"${name}"` : "all marketplaces"}...`));
+      await refreshMarketplaceCache(name);
+      console.log(chalk25.green(`Marketplace cache refreshed.`));
+    } catch (err) {
+      console.error(chalk25.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
   });
@@ -10524,7 +10883,7 @@ async function runWithWatch(interval, fn) {
     await new Promise((r) => setTimeout(r, interval * 1000));
   }
 }
-program.name("todoist").description("CLI tool for managing Todoist tasks").version("0.2.0").option("--debug", "Enable debug output").hook("preAction", () => {
+program.name("todoist").description("CLI tool for managing Todoist tasks").version("0.4.0").option("--debug", "Enable debug output").hook("preAction", () => {
   if (program.opts().debug) {
     setDebug(true);
     debug("Debug mode enabled");

package/marketplace.json

@@ -0,0 +1,16 @@
+{
+  "name": "todoist-cli-official",
+  "description": "Official todoist-cli plugin marketplace",
+  "version": "1.0.0",
+  "plugins": [
+    {
+      "name": "time-tracking",
+      "source": "./plugins/time-tracking",
+      "version": "1.0.0",
+      "description": "Track time spent on tasks",
+      "author": "todoist-cli",
+      "category": "productivity",
+      "keywords": ["time", "tracking", "timer", "report"]
+    }
+  ]
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@mindtnv/todoist-cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A fast, keyboard-driven Todoist client for the terminal — interactive TUI and scriptable CLI",
   "type": "module",
   "bin": {
     "todoist": "dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "marketplace.json"
   ],
   "scripts": {
     "dev": "bun run src/cli/index.ts",