howcode 0.1.1 → 0.1.2

package/README.md

@@ -1,8 +1,16 @@
 # howcode
 
-Launch the Howcode desktop app from npm.
+Howcode is a desktop app for coding with Pi.
 
-## Use
+It gives you:
+
+- threaded Pi chats tied to your projects
+- a built-in terminal
+- project and inbox sidebars
+- git and diff workflows in the app, with some early-release actions still partial
+- local desktop performance instead of a browser tab
+
+## Install / run
 
 ```bash
 npx howcode
@@ -11,17 +19,28 @@ npm i -g howcode
 howcode
 ```
 
-On first run, the launcher downloads the matching desktop build from GitHub Releases and caches it locally.
+This npm package is a small launcher.
 
-## Linux note
+On first run, it downloads the matching desktop app for your platform from GitHub Releases and caches it locally.
+After the first successful download, it can fall back to the cached app if release metadata is temporarily unavailable.
 
-If the Linux build hits a WebKit/GBM white-screen issue, the launcher retries with `WEBKIT_DISABLE_DMABUF_RENDERER=1` automatically.
+## What you actually get
 
-If you are launching a downloaded Linux release asset manually, use:
+- macOS, Linux, and Windows desktop builds
+- Linux AppImage artifacts for direct installs
+- local cached installs after first download
+- desktop builds that bundle Electron/Chromium for a more consistent renderer
 
-```bash
-WEBKIT_DISABLE_DMABUF_RENDERER=1 ./howcode/bin/launcher
-```
+## Project
+
+- App repo: https://github.com/IgorWarzocha/howcode
+- Issues: https://github.com/IgorWarzocha/howcode/issues
+
+## Renderer note
+
+Release builds now bundle Electron/Chromium on macOS, Linux, and Windows. The launcher no longer needs to inject the old Linux `WEBKIT_DISABLE_DMABUF_RENDERER` workaround.
+
+Expect downloads to be larger than the native-webview builds in exchange for more consistent rendering behavior.
 
 ## Cache location
 

package/lib/howcode.js

@@ -1,51 +1,52 @@
 const fs = require("node:fs");
 const fsp = require("node:fs/promises");
+const crypto = require("node:crypto");
 const os = require("node:os");
 const path = require("node:path");
-const { spawn, spawnSync } = require("node:child_process");
+const { spawn } = require("node:child_process");
 const { pipeline } = require("node:stream/promises");
 const { Readable } = require("node:stream");
+const tar = require("tar");
 
 const packageJson = require("../package.json");
 
 const APP_NAME = packageJson.howcode.appName;
 const RELEASE_BASE_URL = process.env.HOWCODE_BASE_URL || packageJson.howcode.releaseBaseUrl;
+const DOWNLOAD_TIMEOUT_MS = 5 * 60_000;
 
 const TARGETS = {
   "darwin:arm64": {
     os: "macos",
     arch: "arm64",
-    executable: `${APP_NAME}.app/Contents/MacOS/launcher`,
+    executable: `${APP_NAME}.app/Contents/MacOS/${APP_NAME}`,
   },
   "darwin:x64": {
     os: "macos",
     arch: "x64",
-    executable: `${APP_NAME}.app/Contents/MacOS/launcher`,
+    executable: `${APP_NAME}.app/Contents/MacOS/${APP_NAME}`,
   },
   "linux:arm64": {
     os: "linux",
     arch: "arm64",
-    executable: `${APP_NAME}/bin/launcher`,
+    executable: `${APP_NAME}/${APP_NAME}`,
   },
   "linux:x64": {
     os: "linux",
     arch: "x64",
-    executable: `${APP_NAME}/bin/launcher`,
+    executable: `${APP_NAME}/${APP_NAME}`,
   },
   "win32:arm64": {
     os: "win",
-    arch: "x64",
-    executable: `${APP_NAME}/bin/launcher.exe`,
+    arch: "arm64",
+    executable: `${APP_NAME}/${APP_NAME}.exe`,
   },
   "win32:x64": {
     os: "win",
     arch: "x64",
-    executable: `${APP_NAME}/bin/launcher.exe`,
+    executable: `${APP_NAME}/${APP_NAME}.exe`,
   },
 };
 
-const LINUX_DMABUF_FAILURE_PATTERNS = [/Failed to create GBM buffer/i, /GLXBadWindow/i, /dmabuf/i];
-
 function readJsonIfPresent(filePath) {
   try {
     return JSON.parse(fs.readFileSync(filePath, "utf8"));
@@ -110,9 +111,9 @@ async function fetchJson(url) {
   }
 }
 
-async function downloadFile(url, filePath) {
+async function downloadFile(url, filePath, timeoutMs = DOWNLOAD_TIMEOUT_MS) {
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 60_000);
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
 
   try {
     const response = await fetch(url, { signal: controller.signal });
@@ -127,6 +128,12 @@ async function downloadFile(url, filePath) {
   }
 }
 
+async function sha256File(filePath) {
+  const hash = crypto.createHash("sha256");
+  await pipeline(fs.createReadStream(filePath), hash);
+  return hash.digest("hex");
+}
+
 async function resolveLatestRelease(target) {
   const updateUrl = `${RELEASE_BASE_URL}/stable-${target.os}-${target.arch}-update.json`;
   const metadata = await fetchJson(updateUrl);
@@ -153,16 +160,19 @@ async function installRelease(target, releaseInfo, paths) {
   await fsp.mkdir(tempRoot, { recursive: true });
   await fsp.mkdir(path.dirname(paths.installDir), { recursive: true });
   await downloadFile(releaseInfo.assetUrl, archivePath);
-  await fsp.mkdir(tempInstallDir, { recursive: true });
 
-  const extract = spawnSync("tar", ["-xzf", archivePath, "-C", tempInstallDir], {
-    stdio: "inherit",
-  });
-
-  if (extract.status !== 0) {
-    throw new Error("Failed to extract downloaded archive with `tar -xzf`.");
+  const archiveHash = await sha256File(archivePath);
+  if (archiveHash !== releaseInfo.hash) {
+    await fsp.rm(tempRoot, { recursive: true, force: true });
+    throw new Error(
+      `Downloaded archive hash mismatch. Expected ${releaseInfo.hash}, got ${archiveHash}.`,
+    );
   }
 
+  await fsp.mkdir(tempInstallDir, { recursive: true });
+
+  await tar.x({ file: archivePath, cwd: tempInstallDir });
+
   if (!fs.existsSync(path.join(tempInstallDir, target.executable))) {
     throw new Error(`Downloaded archive did not contain ${target.executable}.`);
   }
@@ -213,127 +223,16 @@ function spawnLauncherProcess(executablePath, options = {}) {
     cwd: path.dirname(executablePath),
     env: {
       ...process.env,
+      HOWCODE_REPO_ROOT: process.env.HOWCODE_REPO_ROOT || process.cwd(),
       ...(options.env || {}),
     },
   });
 }
 
-function killDetachedProcess(child) {
-  if (!child.pid) {
-    return;
-  }
-
-  try {
-    if (process.platform !== "win32") {
-      process.kill(-child.pid, "SIGTERM");
-      return;
-    }
-  } catch {}
-
-  try {
-    child.kill("SIGTERM");
-  } catch {}
-}
-
-function hasLinuxDmabufFailure(output) {
-  return LINUX_DMABUF_FAILURE_PATTERNS.some((pattern) => pattern.test(output));
-}
-
-function trimLauncherLog(output) {
-  return output.trim().split(/\r?\n/).slice(-10).join("\n");
-}
-
 async function launch(executablePath) {
-  if (process.platform !== "linux" || process.env.WEBKIT_DISABLE_DMABUF_RENDERER === "1") {
-    const child = spawnLauncherProcess(executablePath);
-    child.unref();
-    return;
-  }
-
-  const child = spawnLauncherProcess(executablePath, {
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  let output = "";
-  const appendOutput = (chunk) => {
-    output += chunk.toString();
-    if (output.length > 32_000) {
-      output = output.slice(-32_000);
-    }
-  };
+  const child = spawnLauncherProcess(executablePath);
 
-  child.stdout?.on("data", appendOutput);
-  child.stderr?.on("data", appendOutput);
-
-  const outcome = await new Promise((resolve) => {
-    let settled = false;
-
-    const finish = (value) => {
-      if (settled) {
-        return;
-      }
-
-      settled = true;
-      clearTimeout(timer);
-      resolve(value);
-    };
-
-    const checkForFallback = () => {
-      if (hasLinuxDmabufFailure(output)) {
-        finish({ type: "fallback" });
-      }
-    };
-
-    const timer = setTimeout(() => finish({ type: "ok" }), 4_000);
-
-    child.stdout?.on("data", checkForFallback);
-    child.stderr?.on("data", checkForFallback);
-    child.once("error", (error) => finish({ type: "error", error }));
-    child.once("exit", (code, signal) => {
-      if (hasLinuxDmabufFailure(output)) {
-        finish({ type: "fallback" });
-        return;
-      }
-
-      finish({ type: "exit", code, signal });
-    });
-  });
-
-  child.stdout?.destroy();
-  child.stderr?.destroy();
   child.unref();
-
-  if (outcome.type === "fallback") {
-    killDetachedProcess(child);
-
-    const fallbackChild = spawnLauncherProcess(executablePath, {
-      env: {
-        WEBKIT_DISABLE_DMABUF_RENDERER: "1",
-      },
-    });
-
-    fallbackChild.unref();
-    return;
-  }
-
-  if (outcome.type === "ok") {
-    return;
-  }
-
-  if (outcome.type === "error") {
-    throw outcome.error;
-  }
-
-  if (outcome.code === 0) {
-    return;
-  }
-
-  const logTail = trimLauncherLog(output);
-  throw new Error(
-    logTail
-      ? `Desktop launcher exited early.\n${logTail}`
-      : `Desktop launcher exited early with code ${outcome.code ?? "unknown"}.`,
-  );
 }
 
 async function main() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "howcode",
-  "version": "0.1.1",
-  "description": "Launch the Howcode desktop app from npm or npx.",
+  "version": "0.1.2",
+  "description": "Desktop coding app for Pi with projects, terminal, git, and diff workflows.",
   "license": "MIT",
   "author": "Igor Warzocha",
   "homepage": "https://github.com/IgorWarzocha/howcode",
@@ -16,10 +16,13 @@
     "howcode": "bin/howcode.js"
   },
   "files": ["bin", "lib", "README.md", "LICENSE"],
+  "dependencies": {
+    "tar": "^7.5.1"
+  },
   "engines": {
     "node": ">=18"
   },
-  "keywords": ["desktop", "launcher", "pi", "coding"],
+  "keywords": ["desktop", "coding", "ai", "terminal", "git", "diff", "assistant"],
   "howcode": {
     "appName": "howcode",
     "releaseBaseUrl": "https://github.com/IgorWarzocha/howcode/releases/latest/download"