aegis-desktop 0.5.0 → 0.5.3

package/lib/local/tools.js

@@ -81,14 +81,12 @@ const fail = (error) => ({ ok: false, error: cap(error) });
 const SCHEMAS = {
   readFile: {
     name: 'readFile',
-    description:
-      'Reads a file from the local filesystem. The file_path parameter must be an absolute path. ' +
-      'Returns line-numbered content.',
+    description: 'Read a file. Absolute path. Returns line-numbered content.',
     parameters: {
       type: 'object',
       properties: {
-        file_path: { type: 'string', description: 'The absolute path to the file to read' },
-        offset: { type: 'number', description: 'The line number to start reading from (0-based)' },
+        file_path: { type: 'string', description: 'Absolute path' },
+        offset: { type: 'number', description: 'Start line (0-based)' },
         limit: { type: 'number', description: `The number of lines to read (max 10000, default ${READ_LINE_CAP})` },
       },
       required: ['file_path'],
@@ -98,13 +96,12 @@ const SCHEMAS = {
   writeFile: {
     name: 'writeFile',
     description:
-      'Writes a file to the local filesystem. Parent directories are created automatically. ' +
-      'Use it to create or replace a whole file; it overwrites whatever was there.',
+      'Write a whole file, overwriting it. Parent dirs are created. Use editFile to change part of one.',
     parameters: {
       type: 'object',
       properties: {
-        file_path: { type: 'string', description: 'The absolute path to the file to write' },
-        content: { type: 'string', description: 'The full contents of the file' },
+        file_path: { type: 'string', description: 'Absolute path' },
+        content: { type: 'string', description: 'Full file contents' },
       },
       required: ['file_path', 'content'],
       additionalProperties: false,
@@ -113,16 +110,15 @@ const SCHEMAS = {
   editFile: {
     name: 'editFile',
     description:
-      'Performs an exact string replacement in a file. old_string must be unique in the file ' +
-      'unless replace_all is true. Use this instead of writeFile when changing part of an ' +
-      'existing file — it fails loudly on a non-unique or missing match instead of guessing.',
+      'Exact string replacement. old_string must be unique unless replace_all. Fails loudly on a ' +
+      'missing or ambiguous match rather than guessing.',
     parameters: {
       type: 'object',
       properties: {
-        file_path: { type: 'string', description: 'The absolute path to the file to modify' },
-        old_string: { type: 'string', description: 'The text to replace (must be unique unless replace_all is true)' },
-        new_string: { type: 'string', description: 'The text to replace it with' },
-        replace_all: { type: 'boolean', description: 'If true, replace all occurrences of old_string' },
+        file_path: { type: 'string', description: 'Absolute path' },
+        old_string: { type: 'string', description: 'Text to replace; must be unique unless replace_all' },
+        new_string: { type: 'string', description: 'Replacement text' },
+        replace_all: { type: 'boolean', description: 'Replace every occurrence' },
       },
       required: ['file_path', 'old_string', 'new_string'],
       additionalProperties: false,
@@ -130,9 +126,7 @@ const SCHEMAS = {
   },
   listDir: {
     name: 'listDir',
-    description:
-      'Lists one directory (non-recursive). Directories are marked with a trailing slash. ' +
-      'Skips node_modules, .git and dist.',
+    description: 'List one directory (non-recursive). Skips node_modules, .git, dist.',
     parameters: {
       type: 'object',
       properties: {
@@ -145,12 +139,12 @@ const SCHEMAS = {
   glob: {
     name: 'glob',
     description:
-      'Find files matching a glob pattern. Supports **, * and ?. Skips node_modules, .git and dist by default.',
+      'Find files by glob (**, *, ?). Skips node_modules, .git, dist.',
     parameters: {
       type: 'object',
       properties: {
-        pattern: { type: 'string', description: 'The glob pattern to match, e.g. "**/*.test.js"' },
-        path: { type: 'string', description: 'The directory to search from (default: the working directory)' },
+        pattern: { type: 'string', description: 'Glob, e.g. "**/*.test.js"' },
+        path: { type: 'string', description: 'Search root (default: cwd)' },
       },
       required: ['pattern'],
       additionalProperties: false,
@@ -158,9 +152,7 @@ const SCHEMAS = {
   },
   grep: {
     name: 'grep',
-    description:
-      'Search file contents using a regular expression. Returns file:line matches. ' +
-      'Skips node_modules, .git and dist by default.',
+    description: 'Search file contents by regex. Returns file:line matches. Skips node_modules, .git, dist.',
     parameters: {
       type: 'object',
       properties: {
@@ -174,15 +166,13 @@ const SCHEMAS = {
   exec: {
     name: 'exec',
     description:
-      'Executes a shell command in a persistent shell session and returns its combined ' +
-      'stdout+stderr plus the exit code. State (cd, exported env vars) carries across calls ' +
-      'within the same turn — it is a real session, not a fresh process each time. ' +
-      'Use for system operations, git commands and package management.',
+      'Run a shell command in a PERSISTENT session: cd and exported env carry across calls in ' +
+      'this turn. Returns stdout+stderr and the exit code. Use for git, packages, system ops.',
     parameters: {
       type: 'object',
       properties: {
-        command: { type: 'string', description: 'The shell command to execute' },
-        cwd: { type: 'string', description: 'Run this one command in a different directory without moving the session (the session cwd is unchanged for later calls)' },
+        command: { type: 'string', description: 'Command to run' },
+        cwd: { type: 'string', description: 'Run this one command elsewhere; session cwd unchanged' },
         timeout: { type: 'number', description: `Timeout in milliseconds (max ${EXEC_TIMEOUT_CAP}, default ${EXEC_TIMEOUT_DEFAULT})` },
         description: { type: 'string', description: 'A brief description of what the command does (for display)' },
       },
@@ -193,17 +183,12 @@ const SCHEMAS = {
   task: {
     name: 'task',
     description:
-      'Spawn a specialized subagent to autonomously handle a focused, multi-step sub-task. ' +
-      'The subagent runs its own tool loop (readFile/writeFile/editFile/listDir/glob/grep/exec) ' +
-      'on the same model and returns a final report as the tool result. Use it to delegate work ' +
-      'like scanning for vulnerabilities, reviewing code, planning a refactor, or scaffolding a ' +
-      'component — give it a complete, self-contained prompt since it cannot ask follow-up ' +
-      'questions. Subagents can delegate further with task, so a large job can be split ' +
-      'hierarchically as deep as useful.',
+      'Delegate a focused multi-step sub-task to a subagent with its own tool loop; it returns a ' +
+      'final report. Give it a complete, self-contained prompt — it cannot ask follow-ups.',
     parameters: {
       type: 'object',
       properties: {
-        description: { type: 'string', description: 'A short (3-5 word) description of the sub-task' },
+        description: { type: 'string', description: 'Short label (3-5 words)' },
         subagent_type: {
           type: 'string',
           enum: [...agentRoles(), 'general'],

package/main.js

@@ -195,6 +195,44 @@ function errorText(err) {
   return err && err.message ? err.message : String(err);
 }
 
+/**
+ * Result shape for the two billing actions (`aegis:billingCheckout` and
+ * `aegis:tokenBankTopup`). Both end in a Stripe-hosted checkout URL created
+ * server-side, and both have failure modes the user has to be able to tell
+ * apart: the free-plan cap (402), no/invalid API key (401), an amount the
+ * server rejects (400), Stripe not configured on the server (503
+ * `setup_required`), and a plain transport/500 error.
+ *
+ * The classification happens HERE for the same reason the memory paths
+ * normalise: `ipcRenderer.invoke` carries only the message STRING across the
+ * boundary, so `err.status` / `err.data` are gone by the time the renderer
+ * sees a rejection. The renderer gets a resolved payload instead — never a
+ * throw it would have to string-match.
+ */
+async function billingResult(run) {
+  try {
+    const data = await run();
+    return {
+      ok: true,
+      url: (data && data.url) || null,
+      status: 0,
+      reason: null,
+      setupRequired: false,
+      upgrade: null,
+    };
+  } catch (err) {
+    const data = (err && err.data) || {};
+    return {
+      ok: false,
+      url: null,
+      status: (err && err.status) || 0,
+      reason: errorText(err),
+      setupRequired: Boolean(data.setup_required),
+      upgrade: upgradeInfo(err),
+    };
+  }
+}
+
 /**
  * `aegis:memorySave` with the offline-first fallback (plan P3 §7): try the
  * cloud save first; if it fails (no key, offline, transient error) queue the
@@ -381,6 +419,15 @@ function createIpcDispatch(aegis, dir, persistApiKey, openExternal) {
     verifyApiKey: () => aegis.verifyApiKey(),
     tokenBankBalance: () => aegis.tokenBankBalance(),
 
+    // Billing (plan upgrade + token-bank top-up). aegis1 creates a Stripe
+    // checkout session and answers `{ url }`; the renderer opens that URL
+    // through the same aegis:openExternal path the upgrade notices use, so a
+    // payment page is never rendered inside the app's own window. Both
+    // resolve a shaped result instead of rejecting — see billingResult().
+    billingCheckout: () => billingResult(() => aegis.billingCheckout()),
+    tokenBankTopup: (payload) =>
+      billingResult(() => aegis.tokenBankTopup(payload && payload.amountEur)),
+
     listModels: () => aegis.listModels(),
 
     chatCompletion: (payload) =>
@@ -969,6 +1016,79 @@ const UPDATE_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000;
  * matches the "never auto-restart without consent" rule: quitAndInstall()
  * is likewise only ever invoked by an explicit "Restart to install" click.
  */
+
+/**
+ * Update state backed by the npm registry, for installs that are not packaged
+ * electron builds (i.e. `npm i -g aegis-desktop`).
+ *
+ * Mirrors the electron-updater manager's shape exactly so the IPC dispatch and
+ * the renderer banner need no branch: status/check/download/quitAndInstall/
+ * start. `download` and `quitAndInstall` are no-ops that report the install
+ * command instead of acting — npm owns installation here, and silently
+ * swapping the package under a running process is not something to do on the
+ * user's behalf.
+ */
+function createNpmUpdateManager({ onStatus }) {
+  const PKG = 'aegis-desktop';
+  let current = 'unknown';
+  try {
+    current = require('./package.json').version;
+  } catch {
+    /* version is cosmetic here */
+  }
+  let state = { status: 'idle', version: null, error: null, channel: 'npm' };
+  const set = (patch) => {
+    state = { ...state, ...patch };
+    if (onStatus) onStatus(state);
+    return state;
+  };
+
+  // Same repo-then-vendor idiom every other shared module here uses.
+  let updater = null;
+  try {
+    updater = require('../client/update.js');
+  } catch {
+    try {
+      updater = require('./vendor/update.js');
+    } catch {
+      updater = null;
+    }
+  }
+
+  async function check() {
+    if (!updater) return set({ status: 'disabled', error: 'update checker unavailable' });
+    set({ status: 'checking', error: null });
+    try {
+      const latest = await updater.fetchLatest({ pkg: PKG });
+      if (!latest) return set({ status: 'error', error: 'registry unreachable' });
+      if (!updater.isNewer(latest, current)) return set({ status: 'up-to-date', version: latest });
+      return set({
+        status: 'available',
+        version: latest,
+        command: `npm i -g ${PKG}@latest`,
+      });
+    } catch (err) {
+      return set({ status: 'error', error: errorText(err) });
+    }
+  }
+
+  return {
+    status: () => state,
+    check,
+    // npm installs are the user's to run; saying so beats pretending to act.
+    download: async () => set({
+      status: state.status === 'available' ? 'available' : state.status,
+      command: `npm i -g ${PKG}@latest`,
+    }),
+    quitAndInstall: () => {},
+    start: () => {
+      check().catch(() => {});
+      const t = setInterval(() => check().catch(() => {}), UPDATE_CHECK_INTERVAL_MS);
+      if (t.unref) t.unref();
+    },
+  };
+}
+
 function createUpdateManager({ autoUpdater, isPackaged, onStatus }) {
   let state = { status: 'idle', version: null, error: null };
 
@@ -978,14 +1098,23 @@ function createUpdateManager({ autoUpdater, isPackaged, onStatus }) {
   }
 
   if (!isPackaged || !autoUpdater) {
-    const disabledState = { status: 'disabled', version: null, error: null };
-    return {
-      status: () => disabledState,
-      check: () => Promise.resolve(disabledState),
-      download: () => Promise.resolve(disabledState),
-      quitAndInstall: () => {},
-      start: () => {},
-    };
+    // Not a packaged build — which is how this app is INSTALLED FROM NPM, not
+    // just how it runs in dev. That case used to resolve a flat 'disabled' and
+    // never check anything, so an npm-installed desktop could never learn a
+    // new version existed.
+    //
+    // electron-updater's configured feed is GitHub Releases
+    // (electron-builder.yml `publish:`), and there has never been a published
+    // release to read — the only one is a draft, invisible to the updater, and
+    // the release workflow cannot run while Actions is billing-locked. So the
+    // feed the packaged path depends on does not exist, while the registry we
+    // actually publish to does.
+    //
+    // npm is therefore the real update channel. Checking it costs one request
+    // a day, reports the version and the exact command, and deliberately does
+    // NOT self-install: replacing your own running process mid-session is a
+    // different promise from telling you an update exists.
+    return createNpmUpdateManager({ onStatus: setState });
   }
 
   autoUpdater.autoDownload = false;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegis-desktop",
   "productName": "AEGIS Desktop",
-  "version": "0.5.0",
+  "version": "0.5.3",
   "description": "Thin Electron host for AEGIS — a local chat UI over the shared client/aegis.js transport. Ships transport + UI only; engine logic stays server-side.",
   "author": {
     "name": "AEGIS Code",

package/preload.js

@@ -86,6 +86,12 @@ const api = {
   setApiKey: (key) => invoke('setApiKey', { key }),
   verifyApiKey: () => invoke('verifyApiKey'),
   tokenBankBalance: () => invoke('tokenBankBalance'),
+  // Billing: both start a Stripe-hosted checkout and resolve a shaped
+  // `{ ok, url | status, reason, upgrade }` (main.js billingResult). The
+  // renderer opens the returned URL with openExternal below — the checkout
+  // page itself never loads in this window.
+  billingCheckout: () => invoke('billingCheckout'),
+  tokenBankTopup: (amountEur) => invoke('tokenBankTopup', { amountEur }),
   listModels: () => invoke('listModels'),
   // Streaming chat (D2.1): pass an onDelta callback to receive SSE chunks as
   // they arrive (pushed from main over aegis:chatDelta). The invoke promise