termify-agent 1.0.61 → 1.0.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termify-agent",
-  "version": "1.0.61",
+  "version": "1.0.62",
   "description": "Termify Agent CLI - Connect your local terminal to Termify",
   "type": "module",
   "main": "dist/index.js",

package/scripts/postinstall.js

@@ -14,6 +14,7 @@
  * `termify-agent start` for faster npm install times. See src/setup.ts.
  */
 
+import Conf from 'conf';
 import { execSync } from 'child_process';
 import { createWriteStream, mkdirSync, chmodSync, existsSync, unlinkSync, copyFileSync, rmSync, readFileSync, readlinkSync, writeFileSync, symlinkSync, lstatSync, readdirSync } from 'fs';
 import { isAbsolute, join, dirname, resolve } from 'path';
@@ -33,6 +34,7 @@ const TERMIFY_DIR = join(homedir(), '.termify');
 const DAEMON_PATH = join(TERMIFY_DIR, `termify-daemon${EXE}`);
 const STATS_AGENT_PATH = join(TERMIFY_DIR, `stats-agent${EXE}`);
 const WG_GO_PATH = join(TERMIFY_DIR, 'wireguard-go');
+const DISTILL_MARKER = '## Distill';
 
 // Marker: skip node-pty test on repeated installs if it already works for this ABI
 const NODE_PTY_OK_MARKER = join(TERMIFY_DIR, `.node-pty-ok-${process.versions.modules}`);
@@ -520,6 +522,101 @@ async function setupDistill() {
   return { installed: true, degraded: !reachable, shimPath: distillShimPath };
 }
 
+function readConfiguredServerUrl() {
+  try {
+    const config = new Conf({
+      projectName: 'termify-agent',
+      defaults: {
+        serverUrl: 'https://termify.justdiego.com',
+        servers: [],
+      },
+    });
+
+    const servers = config.get('servers') || [];
+    if (Array.isArray(servers) && servers.length > 0) {
+      const primary = servers.find((server) => server && server.isPrimary) || servers[0];
+      if (primary?.serverUrl) return primary.serverUrl;
+    }
+
+    const serverUrl = config.get('serverUrl');
+    return typeof serverUrl === 'string' && serverUrl ? serverUrl : null;
+  } catch {
+    return null;
+  }
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function insertOrReplaceBlock(content, marker, newBlock) {
+  const markerEscaped = escapeRegExp(marker);
+  const regex = new RegExp(`${markerEscaped}[\\s\\S]*?(?=\\n## |\\n---\\n|$)`, '');
+  if (content.includes(marker)) {
+    return content.replace(regex, newBlock);
+  }
+  return content.trimEnd() + '\n\n' + newBlock + '\n';
+}
+
+function updateInstructionFile(filePath, block, { createIfMissing = true } = {}) {
+  if (!createIfMissing && !existsSync(filePath)) return false;
+  let content = '';
+  if (existsSync(filePath)) {
+    content = readFileSync(filePath, 'utf8');
+  }
+  const next = insertOrReplaceBlock(content, DISTILL_MARKER, block);
+  writeFileSync(filePath, next);
+  return true;
+}
+
+export async function syncBundleMetadata(options = {}) {
+  const homeDir = options.homeDir || homedir();
+  const serverUrl = options.serverUrl || readConfiguredServerUrl();
+  const fetchImpl = options.fetchImpl || fetch;
+  const log = options.log || (() => {});
+
+  if (!serverUrl) {
+    return { synced: false, reason: 'no-server-url' };
+  }
+
+  let manifest;
+  try {
+    const response = await fetchImpl(`${serverUrl}/api/downloads/bundles/manifest`);
+    if (!response?.ok) {
+      return { synced: false, reason: `http-${response?.status || 'unknown'}` };
+    }
+    manifest = await response.json();
+  } catch {
+    return { synced: false, reason: 'fetch-failed' };
+  }
+
+  if (!manifest || manifest.version !== 1) {
+    return { synced: false, reason: 'invalid-manifest' };
+  }
+
+  mkdirSync(join(homeDir, '.termify'), { recursive: true });
+  writeFileSync(join(homeDir, '.termify', 'bundles-manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+
+  if (manifest.distillDefaults) {
+    writeFileSync(join(homeDir, '.termify', 'distill.json'), JSON.stringify(manifest.distillDefaults, null, 2) + '\n');
+  }
+
+  const instructions = manifest.instructions?.distill;
+  if (instructions) {
+    updateInstructionFile(join(homeDir, '.codex', 'instructions.md'), instructions);
+
+    const geminiDir = join(homeDir, '.gemini');
+    if (existsSync(geminiDir)) {
+      updateInstructionFile(join(geminiDir, 'GEMINI.md'), instructions);
+    }
+
+    updateInstructionFile(join(homeDir, '.claude', 'CLAUDE.md'), instructions, { createIfMissing: false });
+  }
+
+  log('[termify-agent] Bundle metadata refreshed');
+  return { synced: true, manifest };
+}
+
 // ---------------------------------------------------------------------------
 // Symlink in /usr/local/bin for sudo access
 // ---------------------------------------------------------------------------
@@ -717,6 +814,18 @@ async function main() {
     s4.warn(`distill skipped ${DIM}(${err.message || 'setup failed'})${RESET}`);
   }
 
+  const s5 = createSpinner('Refreshing bundle metadata...');
+  try {
+    const bundleSync = await syncBundleMetadata({ log: () => {} });
+    if (bundleSync.synced) {
+      s5.succeed('Bundle metadata refreshed');
+    } else {
+      s5.warn(`Bundle metadata skipped ${DIM}(${bundleSync.reason})${RESET}`);
+    }
+  } catch (err) {
+    s5.warn(`Bundle metadata skipped ${DIM}(${err.message || 'sync failed'})${RESET}`);
+  }
+
   unmuteConsole();
 
   console.log('');

package/scripts/postinstall.test.mjs

@@ -1,10 +1,10 @@
 import assert from 'node:assert/strict';
-import { mkdirSync, lstatSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, lstatSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import test from 'node:test';
 
-import { detectGlobalWrapperState, ensureGlobalSymlink } from './postinstall.js';
+import { detectGlobalWrapperState, ensureGlobalSymlink, syncBundleMetadata } from './postinstall.js';
 
 function makeTempDir() {
   return mkdtempSync(join(tmpdir(), 'termify-agent-postinstall-'));
@@ -94,3 +94,64 @@ test('detectGlobalWrapperState treats an up-to-date symlink as ready', (t) => {
   assert.equal(detectGlobalWrapperState(target, desiredPath), 'ready');
   assert.equal(readFileSync(desiredPath, 'utf8'), '#!/usr/bin/env node\n');
 });
+
+test('syncBundleMetadata refreshes the local bundle manifest and distill instructions on reinstall', async (t) => {
+  const tempDir = makeTempDir();
+  const homeDir = join(tempDir, 'home');
+  const codexDir = join(homeDir, '.codex');
+  const geminiDir = join(homeDir, '.gemini');
+  const claudeDir = join(homeDir, '.claude');
+
+  t.after(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  mkdirSync(codexDir, { recursive: true });
+  mkdirSync(geminiDir, { recursive: true });
+  mkdirSync(claudeDir, { recursive: true });
+
+  writeFileSync(join(codexDir, 'instructions.md'), '# Codex Instructions\n');
+  writeFileSync(join(geminiDir, 'GEMINI.md'), '# Gemini Instructions\n');
+  writeFileSync(join(claudeDir, 'CLAUDE.md'), '# Claude Instructions\n');
+
+  const manifest = {
+    version: 1,
+    generatedAt: '2026-03-08T00:11:59Z',
+    mcps: [],
+    hooks: [],
+    hookDefinitions: {},
+    mcpRegistrations: {},
+    instructions: {
+      distill: '## Distill\n\nUse `distill -- <command>` for token reduction.\n',
+    },
+    distillDefaults: {
+      primaryHost: 'https://termify.justdiego.com/api/ollama',
+      primaryModel: 'huihui_ai/qwen3.5-abliterated:2b',
+      timeoutMs: 10000,
+      thinking: false,
+    },
+  };
+
+  const result = await syncBundleMetadata({
+    homeDir,
+    serverUrl: 'https://termify.justdiego.com',
+    fetchImpl: async () => ({
+      ok: true,
+      json: async () => manifest,
+    }),
+    log: () => {},
+  });
+
+  assert.equal(result.synced, true);
+
+  const localManifestPath = join(homeDir, '.termify', 'bundles-manifest.json');
+  const distillConfigPath = join(homeDir, '.termify', 'distill.json');
+
+  assert.equal(existsSync(localManifestPath), true);
+  assert.equal(existsSync(distillConfigPath), true);
+  assert.match(readFileSync(join(codexDir, 'instructions.md'), 'utf8'), /^## Distill/m);
+  assert.match(readFileSync(join(geminiDir, 'GEMINI.md'), 'utf8'), /^## Distill/m);
+  assert.match(readFileSync(join(claudeDir, 'CLAUDE.md'), 'utf8'), /^## Distill/m);
+  assert.equal(JSON.parse(readFileSync(localManifestPath, 'utf8')).generatedAt, '2026-03-08T00:11:59Z');
+  assert.equal(JSON.parse(readFileSync(distillConfigPath, 'utf8')).primaryModel, 'huihui_ai/qwen3.5-abliterated:2b');
+});