taskair-cli 1.0.5 → 1.0.6

package/dist/index.js

@@ -981,6 +981,50 @@ function computeStats() {
   };
 }
 
+// src/lib/crypto.ts
+import {
+  pbkdf2Sync,
+  createCipheriv,
+  createDecipheriv,
+  randomBytes,
+  createHash
+} from "crypto";
+var PBKDF2_ITERATIONS = 1e5;
+var KEY_LENGTH = 32;
+var SALT_LENGTH = 16;
+var IV_LENGTH = 16;
+function deriveMasterKey(password, salt) {
+  return pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
+}
+function deriveEncryptionKey(masterKey) {
+  const hash = createHash("sha256");
+  hash.update(masterKey);
+  hash.update("taskair-encryption");
+  return hash.digest();
+}
+function encrypt(plaintext, password) {
+  const salt = randomBytes(SALT_LENGTH);
+  const iv = randomBytes(IV_LENGTH);
+  const masterKey = deriveMasterKey(password, salt);
+  const encKey = deriveEncryptionKey(masterKey);
+  const cipher = createCipheriv("aes-256-gcm", encKey, iv);
+  const encrypted = Buffer.concat([
+    cipher.update(plaintext, "utf8"),
+    cipher.final()
+  ]);
+  const authTag = cipher.getAuthTag();
+  return {
+    version: "1",
+    salt: salt.toString("base64"),
+    iv: iv.toString("base64"),
+    ciphertext: encrypted.toString("base64"),
+    authTag: authTag.toString("base64")
+  };
+}
+function checksum(plaintext) {
+  return createHash("sha256").update(plaintext).digest("hex");
+}
+
 // src/commands/add.tsx
 import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
 function AddUI({
@@ -991,32 +1035,72 @@ function AddUI({
 }) {
   const { exit } = useApp4();
   const [status, setStatus] = useState6("working");
+  const [syncStatus, setSyncStatus] = useState6("idle");
+  const [syncMessage, setSyncMessage] = useState6("");
   const [taskId, setTaskId] = useState6("");
   const [errorMsg, setErrorMsg] = useState6("");
   useEffect6(() => {
-    try {
-      const auth = requireAuth();
-      const task = {
-        id: uuidv42(),
-        description,
-        priority,
-        status: "pending",
-        tags,
-        due_date: due,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-        device_id: auth.deviceId,
-        vector_clock: { [auth.deviceId]: 1 }
-      };
-      insertTask(task);
-      setTaskId(task.id.slice(0, 8));
-      setStatus("success");
-      setTimeout(() => exit(), 1500);
-    } catch (e) {
-      setErrorMsg(e.message);
-      setStatus("error");
-      setTimeout(() => exit(e), 1500);
+    async function createTaskAndSync() {
+      try {
+        const auth = requireAuth();
+        const task = {
+          id: uuidv42(),
+          description,
+          priority,
+          status: "pending",
+          tags,
+          due_date: due,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          device_id: auth.deviceId,
+          vector_clock: { [auth.deviceId]: 1 }
+        };
+        insertTask(task);
+        setTaskId(task.id.slice(0, 8));
+        setStatus("success");
+        setSyncStatus("syncing");
+        const tasks = getAllTasks();
+        const bundle = {
+          tasks,
+          schema_version: "1",
+          exported_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const plaintext = JSON.stringify(bundle);
+        const blobChecksum = checksum(plaintext);
+        const syncPassword = auth.password;
+        if (!syncPassword) {
+          setSyncStatus("failed");
+          setSyncMessage('Encryption password required. Run "taskair sync --password <pwd>".');
+          setTimeout(() => exit(), 3e3);
+          return;
+        }
+        const blob = encrypt(plaintext, syncPassword);
+        const res = await apiUploadSync(
+          auth.apiUrl,
+          auth.accessToken,
+          blob,
+          blobChecksum,
+          auth.deviceId
+        );
+        if (res.success) {
+          clearSyncQueue();
+          setSyncStatus("synced");
+          setTimeout(() => exit(), 2e3);
+        } else if (res.error?.code === "NETWORK_ERROR") {
+          setSyncStatus("offline");
+          setTimeout(() => exit(), 2500);
+        } else {
+          setSyncStatus("failed");
+          setSyncMessage(res.error?.message ?? "Sync failed");
+          setTimeout(() => exit(), 3500);
+        }
+      } catch (e) {
+        setErrorMsg(e.message);
+        setStatus("error");
+        setTimeout(() => exit(e), 2e3);
+      }
     }
+    createTaskAndSync();
   }, []);
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
     /* @__PURE__ */ jsx8(MiniHeader, {}),
@@ -1048,14 +1132,13 @@ function AddUI({
           /* @__PURE__ */ jsx8(Text8, { color: "#7B61FF", children: tags.join(", ") })
         ] }),
         /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, children: [
-          /* @__PURE__ */ jsxs8(Text8, { color: "gray", dimColor: true, children: [
-            "Queued for sync \xB7 Run",
-            " "
-          ] }),
-          /* @__PURE__ */ jsx8(Text8, { color: "cyan", dimColor: true, children: "taskair sync" }),
-          /* @__PURE__ */ jsxs8(Text8, { color: "gray", dimColor: true, children: [
-            " ",
-            "to push to cloud"
+          /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "  Sync:        " }),
+          syncStatus === "syncing" && /* @__PURE__ */ jsx8(Text8, { color: "magenta", children: "Syncing to cloud (E2E encrypted)..." }),
+          syncStatus === "synced" && /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713 Synced to cloud" }),
+          syncStatus === "offline" && /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "\u2601 Offline (queued locally)" }),
+          syncStatus === "failed" && /* @__PURE__ */ jsxs8(Text8, { color: "red", children: [
+            "\u2717 ",
+            syncMessage
           ] })
         ] })
       ] })
@@ -1652,52 +1735,6 @@ function registerStats(program2) {
 // src/commands/sync.tsx
 import React14, { useState as useState11, useEffect as useEffect12 } from "react";
 import { Box as Box15, Text as Text15, useApp as useApp10 } from "ink";
-
-// src/lib/crypto.ts
-import {
-  pbkdf2Sync,
-  createCipheriv,
-  createDecipheriv,
-  randomBytes,
-  createHash
-} from "crypto";
-var PBKDF2_ITERATIONS = 1e5;
-var KEY_LENGTH = 32;
-var SALT_LENGTH = 16;
-var IV_LENGTH = 16;
-function deriveMasterKey(password, salt) {
-  return pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
-}
-function deriveEncryptionKey(masterKey) {
-  const hash = createHash("sha256");
-  hash.update(masterKey);
-  hash.update("taskair-encryption");
-  return hash.digest();
-}
-function encrypt(plaintext, password) {
-  const salt = randomBytes(SALT_LENGTH);
-  const iv = randomBytes(IV_LENGTH);
-  const masterKey = deriveMasterKey(password, salt);
-  const encKey = deriveEncryptionKey(masterKey);
-  const cipher = createCipheriv("aes-256-gcm", encKey, iv);
-  const encrypted = Buffer.concat([
-    cipher.update(plaintext, "utf8"),
-    cipher.final()
-  ]);
-  const authTag = cipher.getAuthTag();
-  return {
-    version: "1",
-    salt: salt.toString("base64"),
-    iv: iv.toString("base64"),
-    ciphertext: encrypted.toString("base64"),
-    authTag: authTag.toString("base64")
-  };
-}
-function checksum(plaintext) {
-  return createHash("sha256").update(plaintext).digest("hex");
-}
-
-// src/commands/sync.tsx
 import { Fragment as Fragment5, jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
 function SyncUI({ dryRun, password }) {
   const { exit } = useApp10();
@@ -1874,17 +1911,18 @@ function registerExport(program2) {
 
 // src/commands/upgrade.tsx
 import React15, { useState as useState12, useEffect as useEffect13 } from "react";
-import { Box as Box16, Text as Text16 } from "ink";
+import { Box as Box16, Text as Text16, useApp as useApp11 } from "ink";
 import { exec as exec2 } from "child_process";
 
 // src/lib/version.ts
-var CLI_VERSION = "1.0.5";
+var CLI_VERSION = "1.0.6";
 
 // src/commands/upgrade.tsx
 import { jsx as jsx16, jsxs as jsxs16 } from "react/jsx-runtime";
 function isOutdated(current, latest) {
-  const cParts = current.split(".").map(Number);
-  const lParts = latest.split(".").map(Number);
+  if (!current) return true;
+  const cParts = current.replace(/^v/, "").split(".").map(Number);
+  const lParts = latest.replace(/^v/, "").split(".").map(Number);
   for (let i = 0; i < 3; i++) {
     const c = cParts[i] ?? 0;
     const l = lParts[i] ?? 0;
@@ -1893,40 +1931,159 @@ function isOutdated(current, latest) {
   }
   return false;
 }
-function UpgradeUI() {
-  const [status, setStatus] = useState12("checking");
-  const [latestVersion, setLatestVersion] = useState12("");
-  const [errorMsg, setErrorMsg] = useState12("");
+function UpgradeUI({ target }) {
+  const { exit } = useApp11();
+  const shouldUpgradeCli = !target || target.toLowerCase() === "cli";
+  const shouldUpgradeMcp = !target || target.toLowerCase() === "mcp";
+  const [cliState, setCliState] = useState12({
+    name: "TaskAir CLI",
+    pkgName: "taskair-cli",
+    current: CLI_VERSION,
+    latest: "",
+    status: shouldUpgradeCli ? "checking" : "up-to-date",
+    errorMsg: ""
+  });
+  const [mcpState, setMcpState] = useState12({
+    name: "TaskAir MCP Server",
+    pkgName: "taskair-mcp",
+    current: "",
+    latest: "",
+    status: shouldUpgradeMcp ? "checking" : "up-to-date",
+    errorMsg: ""
+  });
   useEffect13(() => {
     async function checkAndUpgrade() {
-      try {
-        const res = await fetch("https://registry.npmjs.org/taskair-cli/latest", {
-          signal: AbortSignal.timeout(5e3)
-          // 5s timeout
+      const tasks = [];
+      let mcpCurrent = "";
+      if (shouldUpgradeMcp) {
+        mcpCurrent = await new Promise((resolve) => {
+          exec2("npm list -g taskair-mcp --json", (err, stdout) => {
+            if (err) {
+              resolve("");
+              return;
+            }
+            try {
+              const data = JSON.parse(stdout);
+              resolve(data.dependencies?.["taskair-mcp"]?.version || "");
+            } catch {
+              resolve("");
+            }
+          });
         });
-        if (!res.ok) {
-          throw new Error(`Failed to fetch latest version from npm registry. Status: ${res.status}`);
+      }
+      let cliLatest = "";
+      if (shouldUpgradeCli) {
+        try {
+          const res = await fetch("https://registry.npmjs.org/taskair-cli/latest", {
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (res.ok) {
+            const data = await res.json();
+            cliLatest = data.version || "";
+          }
+        } catch {
+          cliLatest = "";
         }
-        const data = await res.json();
-        const latest = data.version || "1.0.4";
-        setLatestVersion(latest);
-        if (isOutdated(CLI_VERSION, latest)) {
-          setStatus("upgrading");
-          exec2("npm install -g taskair-cli", (error, stdout, stderr) => {
-            if (error) {
-              setErrorMsg(error.message || stderr || "Failed to install update");
-              setStatus("error");
-            } else {
-              setStatus("success");
-            }
+      }
+      let mcpLatest = "";
+      if (shouldUpgradeMcp) {
+        try {
+          const res = await fetch("https://registry.npmjs.org/taskair-mcp/latest", {
+            signal: AbortSignal.timeout(5e3)
           });
+          if (res.ok) {
+            const data = await res.json();
+            mcpLatest = data.version || "";
+          }
+        } catch {
+          mcpLatest = "";
+        }
+      }
+      if (shouldUpgradeCli) {
+        if (!cliLatest) {
+          setCliState((prev) => ({
+            ...prev,
+            status: "error",
+            errorMsg: "Could not fetch latest version from registry."
+          }));
         } else {
-          setStatus("up-to-date");
+          setCliState((prev) => ({ ...prev, latest: cliLatest }));
+          if (isOutdated(CLI_VERSION, cliLatest)) {
+            setCliState((prev) => ({ ...prev, status: "upgrading" }));
+            tasks.push(new Promise((resolve) => {
+              exec2("npm install -g taskair-cli", (error, stdout, stderr) => {
+                if (error) {
+                  setCliState((prev) => ({
+                    ...prev,
+                    status: "error",
+                    errorMsg: error.message || stderr || "Failed to install updates"
+                  }));
+                } else {
+                  setCliState((prev) => ({ ...prev, status: "success" }));
+                }
+                resolve();
+              });
+            }));
+          } else {
+            setCliState((prev) => ({ ...prev, status: "up-to-date" }));
+          }
+        }
+      }
+      if (shouldUpgradeMcp) {
+        if (!mcpLatest) {
+          setMcpState((prev) => ({
+            ...prev,
+            status: "error",
+            errorMsg: "Could not fetch latest version from registry."
+          }));
+        } else {
+          setMcpState((prev) => ({ ...prev, latest: mcpLatest, current: mcpCurrent }));
+          const isMcpInstalled = !!mcpCurrent;
+          if (!isMcpInstalled) {
+            if (target === "mcp") {
+              setMcpState((prev) => ({ ...prev, status: "upgrading" }));
+              tasks.push(new Promise((resolve) => {
+                exec2("npm install -g taskair-mcp", (error, stdout, stderr) => {
+                  if (error) {
+                    setMcpState((prev) => ({
+                      ...prev,
+                      status: "error",
+                      errorMsg: error.message || stderr || "Failed to install"
+                    }));
+                  } else {
+                    setMcpState((prev) => ({ ...prev, status: "success" }));
+                  }
+                  resolve();
+                });
+              }));
+            } else {
+              setMcpState((prev) => ({ ...prev, status: "not-installed" }));
+            }
+          } else if (isOutdated(mcpCurrent, mcpLatest)) {
+            setMcpState((prev) => ({ ...prev, status: "upgrading" }));
+            tasks.push(new Promise((resolve) => {
+              exec2("npm install -g taskair-mcp", (error, stdout, stderr) => {
+                if (error) {
+                  setMcpState((prev) => ({
+                    ...prev,
+                    status: "error",
+                    errorMsg: error.message || stderr || "Failed to install updates"
+                  }));
+                } else {
+                  setMcpState((prev) => ({ ...prev, status: "success" }));
+                }
+                resolve();
+              });
+            }));
+          } else {
+            setMcpState((prev) => ({ ...prev, status: "up-to-date" }));
+          }
         }
-      } catch (err) {
-        setErrorMsg(err.message || "Network error checking for updates.");
-        setStatus("error");
       }
+      if (tasks.length > 0) {
+        await Promise.all(tasks);
+      }
+      setTimeout(() => exit(), 2500);
     }
     checkAndUpgrade();
   }, []);
@@ -1934,39 +2091,62 @@ function UpgradeUI() {
     /* @__PURE__ */ jsx16(MiniHeader, {}),
     /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", borderStyle: "round", borderColor: "#7B61FF", paddingX: 2, paddingY: 1, marginTop: 1, children: [
       /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { color: "cyan", bold: true, children: "\u2726 TaskAir Upgrade" }) }),
-      status === "checking" && /* @__PURE__ */ jsx16(Spinner, { label: `Checking npm registry for updates... (Current: v${CLI_VERSION})`, type: "orbit" }),
-      status === "upgrading" && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs16(Text16, { color: "yellow", bold: true, children: [
-          "\u2726 New version detected: v",
+      shouldUpgradeCli && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsx16(Text16, { bold: true, color: "white", children: "TaskAir CLI:" }),
+        cliState.status === "checking" && /* @__PURE__ */ jsx16(Spinner, { label: `Checking latest version... (Current: v${CLI_VERSION})`, type: "orbit" }),
+        cliState.status === "upgrading" && /* @__PURE__ */ jsx16(Spinner, { label: `Upgrading globally: v${CLI_VERSION} \u2192 v${cliState.latest}...`, type: "star", color: "yellow" }),
+        cliState.status === "success" && /* @__PURE__ */ jsxs16(Text16, { color: "green", children: [
+          "\u2713 Successfully upgraded to v",
+          cliState.latest,
+          "!"
+        ] }),
+        cliState.status === "up-to-date" && /* @__PURE__ */ jsxs16(Text16, { color: "gray", children: [
+          "\u2713 Already up to date (v",
           CLI_VERSION,
-          " \u2192 v",
-          latestVersion
+          ")"
         ] }),
-        /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Spinner, { label: "Upgrading globally via npm install -g taskair-cli...", type: "star", color: "yellow" }) })
-      ] }),
-      status === "success" && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsx16(StatusBadge, { type: "success", message: `TaskAir CLI successfully upgraded to v${latestVersion}!` }),
-        /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { color: "gray", children: "You are now running the latest space-grade build." }) })
-      ] }),
-      status === "up-to-date" && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsx16(StatusBadge, { type: "success", message: `TaskAir CLI is already up to date (v${CLI_VERSION}).` }),
-        /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { color: "gray", children: "No upgrade required at this time. Blast off! \u{1F680}" }) })
+        cliState.status === "error" && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs16(Text16, { color: "red", children: [
+            "\u2717 Upgrade failed: ",
+            cliState.errorMsg
+          ] }),
+          /* @__PURE__ */ jsx16(Text16, { color: "gray", dimColor: true, children: "Run manually: npm install -g taskair-cli" })
+        ] })
       ] }),
-      status === "error" && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsx16(StatusBadge, { type: "error", message: `Upgrade failed: ${errorMsg}` }),
-        /* @__PURE__ */ jsxs16(Box16, { marginTop: 1, flexDirection: "column", children: [
-          /* @__PURE__ */ jsx16(Text16, { color: "gray", children: "You can try upgrading manually by running:" }),
-          /* @__PURE__ */ jsx16(Text16, { color: "cyan", bold: true, children: "  npm install -g taskair-cli" }),
-          /* @__PURE__ */ jsx16(Text16, { color: "gray", marginTop: 1, children: "If permission errors occur, run with administrative rights (sudo)." })
+      shouldUpgradeMcp && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx16(Text16, { bold: true, color: "white", children: "TaskAir MCP Server:" }),
+        mcpState.status === "checking" && /* @__PURE__ */ jsx16(Spinner, { label: `Checking latest version... (Current: ${mcpState.current ? "v" + mcpState.current : "not installed"})`, type: "orbit" }),
+        mcpState.status === "upgrading" && /* @__PURE__ */ jsx16(Spinner, { label: `Upgrading globally: ${mcpState.current ? "v" + mcpState.current : "installing"} \u2192 v${mcpState.latest}...`, type: "star", color: "yellow" }),
+        mcpState.status === "success" && /* @__PURE__ */ jsxs16(Text16, { color: "green", children: [
+          "\u2713 Successfully upgraded to v",
+          mcpState.latest,
+          "!"
+        ] }),
+        mcpState.status === "up-to-date" && /* @__PURE__ */ jsxs16(Text16, { color: "gray", children: [
+          "\u2713 Already up to date (v",
+          mcpState.current,
+          ")"
+        ] }),
+        mcpState.status === "not-installed" && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx16(Text16, { color: "yellow", children: "\u2601 Not installed globally." }),
+          /* @__PURE__ */ jsx16(Text16, { color: "gray", dimColor: true, children: "Install manually: npm install -g taskair-mcp" }),
+          /* @__PURE__ */ jsx16(Text16, { color: "gray", dimColor: true, children: "Or install now with: taskair upgrade mcp" })
+        ] }),
+        mcpState.status === "error" && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs16(Text16, { color: "red", children: [
+            "\u2717 Upgrade failed: ",
+            mcpState.errorMsg
+          ] }),
+          /* @__PURE__ */ jsx16(Text16, { color: "gray", dimColor: true, children: "Run manually: npm install -g taskair-mcp" })
         ] })
       ] })
     ] })
   ] });
 }
 function registerUpgrade(program2) {
-  program2.command("upgrade").description("Upgrade TaskAir CLI to the latest version").action(async () => {
+  program2.command("upgrade [target]").description('Upgrade TaskAir CLI and MCP Server. Target can be "cli", "mcp", or omitted to upgrade both.').action(async (target) => {
     const { render } = await import("ink");
-    render(React15.createElement(UpgradeUI));
+    render(React15.createElement(UpgradeUI, { target }));
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskair-cli",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Space-themed, privacy-first task management CLI with E2E encryption",
   "type": "module",
   "bin": {