twokey 1.0.4 → 1.0.6

package/bin/postinstall.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+if (process.env.CI === "true" || process.env.TWOKEY_SKIP_POSTINSTALL === "1") {
+  process.exit(0);
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const cliPath = path.join(__dirname, "twokey.js");
+
+const child = spawn(process.execPath, [cliPath, "--desktop", "--enable-autostart", "--quiet"], {
+  stdio: "ignore",
+  shell: false,
+});
+
+child.on("error", () => process.exit(0));
+child.on("close", () => process.exit(0));

package/bin/twokey.js

@@ -6,14 +6,16 @@ import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 
-const VERSION = "1.0.3";
+const VERSION = process.env.npm_package_version || "1.0.6";
 const DEFAULT_MODEL = process.env.TWOKEY_OLLAMA_MODEL || "qwen2.5:3b";
 const DEFAULT_OLLAMA_URL = process.env.TWOKEY_OLLAMA_URL || "http://127.0.0.1:11434";
 const LATEST_RELEASE_API = "https://api.github.com/repos/meinzeug/twokey/releases/latest";
 const APPIMAGE_DIR = path.join(os.homedir(), ".local", "share", "twokey", "bin");
 const APPIMAGE_PATH = path.join(APPIMAGE_DIR, "twokey-ai.AppImage");
+const APPIMAGE_META_PATH = path.join(APPIMAGE_DIR, "twokey-ai.meta.json");
 
 const args = process.argv.slice(2);
+const QUIET = args.includes("--quiet");
 
 if (args.includes("--help") || args.includes("-h")) {
   printHelp();
@@ -26,13 +28,27 @@ if (args.includes("--version") || args.includes("-v")) {
 }
 
 if (args.includes("--desktop")) {
-  launchDesktopApp().then((started) => {
-    if (started) {
-      console.log("TwoKey desktop app started in background.");
+  launchDesktopApp().then(async (startedCommand) => {
+    if (startedCommand) {
+      if (args.includes("--enable-autostart")) {
+        try {
+          await ensureUserService(startedCommand);
+        } catch (error) {
+          if (!QUIET) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Autostart setup skipped: ${message}`);
+          }
+        }
+      }
+      if (!QUIET) {
+        console.log("TwoKey desktop app started in background.");
+      }
       process.exit(0);
     }
-    console.error("No native desktop binary found in PATH.");
-    console.error("Install the .deb/.AppImage release and ensure 'twokey-ai' is available in PATH.");
+    if (!QUIET) {
+      console.error("No native desktop binary found in PATH.");
+      console.error("Install the .deb/.AppImage release and ensure 'twokey-ai' is available in PATH.");
+    }
     process.exit(1);
   });
 }
@@ -55,15 +71,29 @@ if (onceIndex >= 0) {
     process.exit(1);
   });
 } else {
-  launchDesktopApp().then((started) => {
-    if (started) {
-      console.log("TwoKey desktop app started in background.");
+  launchDesktopApp().then(async (startedCommand) => {
+    if (startedCommand) {
+      if (args.includes("--enable-autostart")) {
+        try {
+          await ensureUserService(startedCommand);
+        } catch (error) {
+          if (!QUIET) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Autostart setup skipped: ${message}`);
+          }
+        }
+      }
+      if (!QUIET) {
+        console.log("TwoKey desktop app started in background.");
+      }
       process.exit(0);
     }
 
-    console.error("Could not start desktop app.");
-    console.error("Tried system binaries and auto-download from GitHub Releases.");
-    console.error("Use 'twokey --cli' to run terminal mode.");
+    if (!QUIET) {
+      console.error("Could not start desktop app.");
+      console.error("Tried system binaries and auto-download from GitHub Releases.");
+      console.error("Use 'twokey --cli' to run terminal mode.");
+    }
     process.exit(1);
   });
 }
@@ -161,46 +191,45 @@ async function askOllama(prompt) {
 }
 
 async function launchDesktopApp() {
+  let appImageReady = false;
+  try {
+    appImageReady = await ensureLocalAppImage();
+  } catch {
+    appImageReady = false;
+  }
+
   const candidates = [];
   if (process.env.TWOKEY_DESKTOP_CMD) {
     candidates.push(process.env.TWOKEY_DESKTOP_CMD);
   }
-  candidates.push("twokey-ai", "twokey-desktop", APPIMAGE_PATH);
+  if (appImageReady) {
+    candidates.push(APPIMAGE_PATH);
+  }
+  candidates.push("twokey-ai", "twokey-desktop");
 
   for (const command of candidates) {
     const started = await spawnDetached(command);
     if (started) {
-      return true;
-    }
-  }
-
-  try {
-    const downloaded = await ensureLocalAppImage();
-    if (downloaded) {
-      return spawnDetached(APPIMAGE_PATH);
+      return command;
     }
-  } catch {
-    return false;
   }
 
-  return false;
+  return null;
 }
 
 async function ensureLocalAppImage() {
-  try {
-    await fs.promises.access(APPIMAGE_PATH, fs.constants.X_OK);
-    return true;
-  } catch {
-    // Not installed yet.
+  await fs.promises.mkdir(APPIMAGE_DIR, { recursive: true });
+
+  const latestAsset = await resolveLatestAppImageAsset();
+  if (!latestAsset) {
+    return hasExecutable(APPIMAGE_PATH);
   }
 
-  await fs.promises.mkdir(APPIMAGE_DIR, { recursive: true });
-  const assetUrl = await resolveLatestAppImageUrl();
-  if (!assetUrl) {
-    return false;
+  if (await isCurrentAppImage(latestAsset)) {
+    return true;
   }
 
-  const response = await fetch(assetUrl, {
+  const response = await fetch(latestAsset.url, {
     headers: {
       "User-Agent": "twokey-cli",
       Accept: "application/octet-stream",
@@ -215,10 +244,19 @@ async function ensureLocalAppImage() {
   await fs.promises.writeFile(APPIMAGE_PATH, data, { mode: 0o755 });
 
   await fs.promises.chmod(APPIMAGE_PATH, 0o755);
+  const meta = {
+    releaseTag: latestAsset.releaseTag,
+    assetName: latestAsset.name,
+    assetId: latestAsset.id,
+    assetSize: latestAsset.size,
+    assetUpdatedAt: latestAsset.updatedAt,
+    downloadedAt: new Date().toISOString(),
+  };
+  await fs.promises.writeFile(APPIMAGE_META_PATH, `${JSON.stringify(meta, null, 2)}\n`, "utf8");
   return true;
 }
 
-async function resolveLatestAppImageUrl() {
+async function resolveLatestAppImageAsset() {
   const response = await fetch(LATEST_RELEASE_API, {
     headers: {
       "User-Agent": "twokey-cli",
@@ -236,7 +274,54 @@ async function resolveLatestAppImageUrl() {
     (asset) => typeof asset?.name === "string" && asset.name.endsWith(".AppImage") && asset.name.includes("amd64"),
   ) || assets.find((asset) => typeof asset?.name === "string" && asset.name.endsWith(".AppImage"));
 
-  return appImage?.browser_download_url ?? null;
+  if (!appImage?.browser_download_url) {
+    return null;
+  }
+
+  return {
+    releaseTag: typeof payload?.tag_name === "string" ? payload.tag_name : "unknown",
+    id: Number.isFinite(appImage.id) ? appImage.id : 0,
+    name: appImage.name,
+    size: Number.isFinite(appImage.size) ? appImage.size : 0,
+    updatedAt: typeof appImage.updated_at === "string" ? appImage.updated_at : "",
+    url: appImage.browser_download_url,
+  };
+}
+
+async function isCurrentAppImage(latestAsset) {
+  if (!(await hasExecutable(APPIMAGE_PATH))) {
+    return false;
+  }
+
+  const [meta, stats] = await Promise.all([readAppImageMeta(), fs.promises.stat(APPIMAGE_PATH)]);
+  if (!meta) {
+    return false;
+  }
+
+  return (
+    meta.releaseTag === latestAsset.releaseTag
+    && meta.assetId === latestAsset.id
+    && meta.assetUpdatedAt === latestAsset.updatedAt
+    && Number(meta.assetSize) === Number(stats.size)
+  );
+}
+
+async function readAppImageMeta() {
+  try {
+    const content = await fs.promises.readFile(APPIMAGE_META_PATH, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+async function hasExecutable(filePath) {
+  try {
+    await fs.promises.access(filePath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 function spawnDetached(command) {
@@ -271,3 +356,63 @@ function printHelp() {
   console.log("Without options, twokey starts the native desktop app in background.");
   console.log("If no desktop binary is installed, twokey tries to download an AppImage from latest GitHub release.");
 }
+
+async function ensureUserService(command) {
+  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  const systemdDir = path.join(configHome, "systemd", "user");
+  const servicePath = path.join(systemdDir, "twokey.service");
+  await fs.promises.mkdir(systemdDir, { recursive: true });
+
+  const content = [
+    "[Unit]",
+    "Description=TwoKey Desktop Assistant",
+    "After=graphical-session.target",
+    "",
+    "[Service]",
+    `ExecStart=/bin/sh -lc ${shellEscape(command)}`,
+    "Restart=on-failure",
+    "RestartSec=3",
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    "",
+  ].join("\n");
+
+  await fs.promises.writeFile(servicePath, content, "utf8");
+
+  await runSystemctlUser(["daemon-reload"]);
+  await runSystemctlUser(["enable", "--now", "twokey.service"]);
+
+  if (!QUIET) {
+    console.log("TwoKey systemd user service enabled: twokey.service");
+  }
+}
+
+async function runSystemctlUser(argsList) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("systemctl", ["--user", ...argsList], {
+      stdio: QUIET ? "ignore" : "pipe",
+      shell: false,
+    });
+
+    let stderr = "";
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        stderr += String(chunk);
+      });
+    }
+
+    child.on("error", (error) => reject(error));
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(stderr.trim() || `systemctl --user failed with code ${code}`));
+    });
+  });
+}
+
+function shellEscape(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "twokey",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Linux-first desktop AI assistant built with Tauri, React, and TypeScript.",
   "license": "MIT",
   "repository": {
@@ -42,6 +42,7 @@
     "preview": "vite preview --host 127.0.0.1",
     "lint": "npm run typecheck",
     "test": "npm run typecheck",
+    "postinstall": "node ./bin/postinstall.js",
     "prepublishOnly": "npm run build && npm pack --dry-run",
     "tauri:dev": "GTK_MODULES='' LIBGL_ALWAYS_SOFTWARE=1 WEBKIT_DISABLE_DMABUF_RENDERER=1 tauri dev",
     "tauri:build": "GTK_MODULES='' LIBGL_ALWAYS_SOFTWARE=1 WEBKIT_DISABLE_DMABUF_RENDERER=1 tauri build"