howcode 0.1.1 → 0.1.3

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,32 @@ 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.
+On Windows, the first successful run also creates a Start Menu shortcut for `howcode`, so you do
+not need to find the cached executable or add the cache directory to `PATH`.
 
-If you are launching a downloaded Linux release asset manually, use:
+## What you actually get
 
-```bash
-WEBKIT_DISABLE_DMABUF_RENDERER=1 ./howcode/bin/launcher
-```
+- macOS, Linux, and Windows desktop builds
+- Windows installer artifacts in GitHub Releases
+- Linux AppImage artifacts for direct installs
+- local cached installs after first download
+- desktop builds that bundle Electron/Chromium for a more consistent renderer
+
+## 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"));
@@ -87,14 +88,134 @@ function getPaths(target, releaseInfo) {
   const versionsRoot = path.join(cacheRoot, "versions");
   const releaseKey = `${releaseInfo.version}-${releaseInfo.hash}`;
   const installDir = path.join(versionsRoot, releaseKey);
+  const launcherWorkingDirectory = path.dirname(path.join(installDir, target.executable));
   return {
     cacheRoot,
     currentFile: path.join(cacheRoot, "current.json"),
+    windowsCommandFile: path.join(cacheRoot, `${APP_NAME}.cmd`),
+    launcherWorkingDirectory,
     installDir,
     executablePath: path.join(installDir, target.executable),
   };
 }
 
+function getWindowsStartMenuShortcutPath() {
+  const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+  return path.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", `${APP_NAME}.lnk`);
+}
+
+function escapeWindowsCommandValue(value) {
+  return value.replace(/%/g, "%%");
+}
+
+function getWindowsScriptHostPath(executableName) {
+  const systemRoot = process.env.SystemRoot || process.env.SYSTEMROOT;
+  if (systemRoot) {
+    return path.join(systemRoot, "System32", executableName);
+  }
+
+  return path.join("C:", "Windows", "System32", executableName);
+}
+
+async function writeWindowsCommandLauncher(paths) {
+  const commandContents = [
+    "@echo off",
+    "chcp 65001 >nul",
+    "setlocal",
+    "set NODE_TLS_REJECT_UNAUTHORIZED=",
+    `set \"HOWCODE_EXE=${escapeWindowsCommandValue(paths.executablePath)}\"`,
+    `set \"HOWCODE_REPO_ROOT=${escapeWindowsCommandValue(paths.launcherWorkingDirectory)}\"`,
+    'if not exist "%HOWCODE_EXE%" (',
+    `  echo ${APP_NAME}: installed app executable was not found.`,
+    `  echo Run npx ${APP_NAME} to repair the local install.`,
+    "  exit /b 1",
+    ")",
+    'start "" /D "%HOWCODE_REPO_ROOT%" "%HOWCODE_EXE%"',
+    "endlocal",
+    "",
+  ].join("\r\n");
+
+  await fsp.writeFile(paths.windowsCommandFile, commandContents, "utf8");
+}
+
+async function createWindowsStartMenuShortcut(paths) {
+  const shortcutPath = getWindowsStartMenuShortcutPath();
+  const shortcutScriptPath = path.join(
+    paths.cacheRoot,
+    `.create-${APP_NAME}-shortcut-${process.pid}.js`,
+  );
+  await fsp.mkdir(path.dirname(shortcutPath), { recursive: true });
+  await fsp.writeFile(
+    shortcutScriptPath,
+    [
+      "var shell = WScript.CreateObject('WScript.Shell');",
+      "var shortcut = shell.CreateShortcut(WScript.Arguments.Item(0));",
+      "shortcut.TargetPath = WScript.Arguments.Item(1);",
+      "shortcut.WorkingDirectory = WScript.Arguments.Item(2);",
+      "shortcut.IconLocation = WScript.Arguments.Item(3);",
+      "shortcut.Description = WScript.Arguments.Item(4);",
+      "shortcut.Save();",
+      "",
+    ].join("\r\n"),
+    "utf8",
+  );
+
+  try {
+    await new Promise((resolve, reject) => {
+      const child = spawn(
+        getWindowsScriptHostPath("cscript.exe"),
+        [
+          "//NoLogo",
+          shortcutScriptPath,
+          shortcutPath,
+          paths.windowsCommandFile,
+          paths.launcherWorkingDirectory,
+          `${paths.executablePath},0`,
+          "howcode",
+        ],
+        { stdio: "ignore", windowsHide: true },
+      );
+      child.on("error", reject);
+      child.on("exit", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`cscript exited with code ${code} while creating Start Menu shortcut.`));
+        }
+      });
+    });
+  } finally {
+    await fsp.rm(shortcutScriptPath, { force: true });
+  }
+
+  return shortcutPath;
+}
+
+async function ensureWindowsLaunchIntegration(target, paths) {
+  if (target.os !== "win") {
+    return true;
+  }
+
+  try {
+    await writeWindowsCommandLauncher(paths);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`${APP_NAME}: could not create command launcher: ${message}`);
+    console.warn(`${APP_NAME}: Start Menu shortcut was not updated.`);
+    return false;
+  }
+
+  try {
+    await createWindowsStartMenuShortcut(paths);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`${APP_NAME}: could not create Start Menu shortcut: ${message}`);
+    console.warn(`${APP_NAME}: you can still relaunch with ${paths.windowsCommandFile}`);
+    return false;
+  }
+}
+
 async function fetchJson(url) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 5000);
@@ -110,9 +231,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 +248,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 +280,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}.`);
   }
@@ -206,134 +336,26 @@ async function pruneOldVersions(cacheRoot, keepDir) {
 }
 
 function spawnLauncherProcess(executablePath, options = {}) {
+  const env = {
+    ...process.env,
+    HOWCODE_REPO_ROOT: process.env.HOWCODE_REPO_ROOT || process.cwd(),
+    ...(options.env || {}),
+  };
+  Reflect.deleteProperty(env, "NODE_TLS_REJECT_UNAUTHORIZED");
+
   return spawn(executablePath, [], {
     detached: true,
     stdio: options.stdio || "ignore",
     windowsHide: true,
     cwd: path.dirname(executablePath),
-    env: {
-      ...process.env,
-      ...(options.env || {}),
-    },
+    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);
-    }
-  };
-
-  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 child = spawnLauncherProcess(executablePath);
 
-    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() {
@@ -348,6 +370,14 @@ async function main() {
     releaseInfo = await resolveLatestRelease(target);
   } catch (error) {
     if (current?.executablePath && fs.existsSync(current.executablePath)) {
+      await ensureWindowsLaunchIntegration(target, {
+        cacheRoot,
+        currentFile: path.join(cacheRoot, "current.json"),
+        windowsCommandFile: path.join(cacheRoot, `${APP_NAME}.cmd`),
+        installDir: current.installDir || path.dirname(path.dirname(current.executablePath)),
+        launcherWorkingDirectory: path.dirname(current.executablePath),
+        executablePath: current.executablePath,
+      });
       await launch(current.executablePath);
       return;
     }
@@ -356,10 +386,15 @@ async function main() {
   }
 
   const paths = getPaths(target, releaseInfo);
+  const didInstall = !fs.existsSync(paths.executablePath);
   if (!fs.existsSync(paths.executablePath)) {
     await installRelease(target, releaseInfo, paths);
   }
 
+  const launchIntegrationReady = await ensureWindowsLaunchIntegration(target, paths);
+  if (target.os === "win" && didInstall && launchIntegrationReady) {
+    console.log(`${APP_NAME}: installed. You can relaunch it from the Windows Start Menu.`);
+  }
   await pruneOldVersions(cacheRoot, paths.installDir);
   await launch(paths.executablePath);
 }

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.3",
+  "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"