cortexcode 0.1.1 → 0.1.3

package/README.md

@@ -7,7 +7,10 @@ npx cortexcode
 Starts [CortexCode](https://github.com/agentbusiness/CortexCode), a local coding agent. The first
 run downloads the app for this machine (Apple Silicon Macs; Linux x64 and arm64) from the official
 releases, checks it against the checksum in the release catalog and unpacks it into `~/.cortexcode/app/`.
-Later runs start the installed app at once; the app updates its frame and plugins itself. The app
+Later runs start the installed app at once; the app updates its frame and plugins itself. It also
+adds CortexCode to your applications (macOS: `/Applications`, or `~/Applications` when that is not
+writable; Linux: `~/.local/share/applications`), which starts the newest installed version, so you
+can open it without a terminal. The app
 runs on its own: you can close the terminal (its start output goes to `~/.cortexcode/logs/start.log`);
 running the command again while it runs only says so.
 

package/bin/cortexcode.mjs

@@ -4,15 +4,16 @@
 // later runs start the installed app at once, without looking at the catalog: the app updates its
 // frame and plugins itself, so a newer app release is only for machines that have none. The app runs
 // on its own: closing the terminal does not quit it (its start output goes to ~/.cortexcode/logs/start.log).
+// Every start also keeps a starter in the Applications folder (macOS) or the app list (Linux).
 // Arguments go to the app (`--headless`, `--safe`).
 
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { closeSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import http from 'node:http';
 import https from 'node:https';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 
 const REPO = process.env.CORTEXCODE_REPO || 'agentbusiness/CortexCode';
@@ -144,6 +145,148 @@ function running() {
   }
 }
 
+// The starter: a small app in the Applications folder (macOS) or the desktop's app list (Linux) that
+// starts the newest installed version, so the app opens without a terminal. It copies nothing of the
+// app, so it keeps working when updates add versions and prune old ones.
+const STARTER_ID = 'ai.cortexcode.starter';
+
+/** `text` quoted for sh. */
+const shq = (text) => `'${String(text).replace(/'/g, `'\\''`)}'`;
+
+/** Write `text` to `path` unless it already holds it; true when it wrote. */
+function writeIfChanged(path, text, mode = 0o644) {
+  mkdirSync(dirname(path), { recursive: true });
+  if (existsSync(path) && readFileSync(path, 'utf8') === text) return false;
+  writeFileSync(path, text);
+  chmodSync(path, mode);
+  return true;
+}
+
+/**
+ * The starter's script: the newest ready version in APPS, started exactly as this launcher starts it
+ * (its binary run directly, detached, output to the start log). Not through `open`: that hands the
+ * bundle to LaunchServices, which starts it differently from a terminal. When the app already runs,
+ * it brings the app's window forward instead (macOS).
+ */
+function starterScript() {
+  const exe = process.platform === 'darwin' ? '$apps/$version/CortexCode.app/Contents/MacOS/CortexCode' : '$apps/$version/cortexcode/CortexCode';
+  // The window belongs to the frame's Electron child: opening that running bundle activates it.
+  const forward =
+    process.platform === 'darwin'
+      ? `  shell="$(ps -axo ppid=,comm= | awk -v p="$pid" '$1 == p && /\\.app\\/Contents\\/MacOS\\// { sub(/^ *[0-9]+ +/, ""); sub(/\\/Contents\\/MacOS\\/.*/, ""); print; exit }')"
+  [ -n "$shell" ] && open "$shell"
+`
+      : '';
+  const missing =
+    process.platform === 'darwin'
+      ? `osascript -e 'display alert "CortexCode is not installed" message "Run npx cortexcode in a terminal to install it."' >/dev/null 2>&1`
+      : 'command -v notify-send >/dev/null 2>&1 && notify-send CortexCode "CortexCode is not installed: run npx cortexcode in a terminal."';
+  return `#!/bin/sh
+# CortexCode starter, written by npx cortexcode: starts the newest app installed in the folder below.
+apps=${shq(APPS)}
+log=${shq(START_LOG)}
+pid="$(sed -n 's/.*"pid": *\\([0-9][0-9]*\\).*/\\1/p' ${shq(join(HOME, 'run', 'frame.json'))} 2>/dev/null)"
+if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+${forward}  exit 0
+fi
+mkdir -p "$(dirname "$log")"
+version="$(ls "$apps" 2>/dev/null | grep -E '^[0-9]+\\.[0-9]+\\.[0-9]+$' | sort -t. -k1,1n -k2,2n -k3,3n |
+  while read -r v; do [ -e "$apps/$v/${READY}" ] && echo "$v"; done | tail -n 1)"
+if [ -z "$version" ]; then
+  ${missing}
+  exit 1
+fi
+# Detached, so the starter ends at once and opening it again finds the running app.
+nohup "${exe}" "$@" >>"$log" 2>&1 </dev/null &
+`;
+}
+
+/** macOS: CortexCode.app in /Applications, or in ~/Applications when /Applications is not writable. */
+function macStarter(appDir) {
+  const places = ['/Applications', join(homedir(), 'Applications')].map((place) => join(place, 'CortexCode.app'));
+  const ours = (bundle) => {
+    try {
+      return readFileSync(join(bundle, 'Contents', 'Info.plist'), 'utf8').includes(STARTER_ID);
+    } catch {
+      return false;
+    }
+  };
+  // A CortexCode.app that is not a starter (the disk image's app) is the user's own: leave it.
+  if (places.some((bundle) => existsSync(join(bundle, 'Contents', 'Info.plist')) && !ours(bundle))) return;
+  let bundle = places.find(ours);
+  const fresh = !bundle;
+  if (!bundle) {
+    for (const place of places) {
+      try {
+        mkdirSync(join(place, 'Contents', 'MacOS'), { recursive: true });
+        bundle = place;
+        break;
+      } catch {
+        // not writable: the next place
+      }
+    }
+  }
+  if (!bundle) throw new Error('neither /Applications nor ~/Applications is writable');
+  // LSUIElement: the starter only hands over to the app, so it never shows in the Dock itself.
+  writeIfChanged(
+    join(bundle, 'Contents', 'Info.plist'),
+    `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleName</key>
+	<string>CortexCode</string>
+	<key>CFBundleDisplayName</key>
+	<string>CortexCode</string>
+	<key>CFBundleIdentifier</key>
+	<string>${STARTER_ID}</string>
+	<key>CFBundleExecutable</key>
+	<string>CortexCode</string>
+	<key>CFBundleIconFile</key>
+	<string>CortexCode.icns</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>LSUIElement</key>
+	<true/>
+</dict>
+</plist>
+`,
+  );
+  writeIfChanged(join(bundle, 'Contents', 'MacOS', 'CortexCode'), starterScript(), 0o755);
+  const icon = join(bundle, 'Contents', 'Resources', 'CortexCode.icns');
+  if (!existsSync(icon)) {
+    mkdirSync(dirname(icon), { recursive: true });
+    copyFileSync(join(appDir, 'CortexCode.app', 'Contents', 'Resources', 'CortexCode.icns'), icon);
+  }
+  if (fresh) say(`CortexCode is in ${dirname(bundle)}: open it from there next time`);
+}
+
+/** Linux: a desktop entry in the app list ($XDG_DATA_HOME/applications) that runs APPS/start. */
+function linuxStarter(appDir) {
+  const script = join(APPS, 'start');
+  const icon = join(APPS, 'cortexcode.png');
+  writeIfChanged(script, starterScript(), 0o755);
+  if (!existsSync(icon)) copyFileSync(join(appDir, 'cortexcode', 'ui', 'shell', 'assets', 'cortexcode-512.png'), icon);
+  const data = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+  const entry = join(data, 'applications', 'cortexcode.desktop');
+  const fresh = !existsSync(entry);
+  writeIfChanged(
+    entry,
+    `[Desktop Entry]
+Type=Application
+Name=CortexCode
+Comment=Local coding agent
+Exec="${script}"
+Icon=${icon}
+Terminal=false
+Categories=Development;
+`,
+  );
+  if (fresh) say('CortexCode is in your applications: open it from there next time');
+}
+
 /** Keep the newest versions (and the one starting now). */
 function prune(keep) {
   installed()
@@ -155,7 +298,7 @@ function prune(keep) {
 async function main() {
   const args = process.argv.slice(2);
   if (args.includes('--help') || args.includes('-h')) {
-    process.stdout.write('npx cortexcode [--headless] [--safe]\n\nStarts CortexCode; the first run downloads it into ~/.cortexcode/app.\n');
+    process.stdout.write('npx cortexcode [--headless] [--safe]\n\nStarts CortexCode; the first run downloads it into ~/.cortexcode/app and adds it to your applications.\n');
     return 0;
   }
   const pid = running();
@@ -181,6 +324,15 @@ async function main() {
     return 1;
   }
   prune(chosen);
+  // Only for the user's own home: a scratch home (CORTEX_HOME) must not take over the starter.
+  if (!process.env.CORTEX_HOME) {
+    try {
+      if (process.platform === 'darwin') macStarter(join(APPS, chosen));
+      else linuxStarter(join(APPS, chosen));
+    } catch (error) {
+      say(`cannot add CortexCode to the applications (${error.message})`);
+    }
+  }
   // Its own session, detached from this terminal: closing the terminal does not quit it.
   mkdirSync(join(HOME, 'logs'), { recursive: true });
   const log = openSync(START_LOG, 'a');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortexcode",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "CortexCode, a local coding agent: npx cortexcode downloads the app for this machine from the official releases and starts it.",
   "type": "module",
   "bin": {