termify-agent 1.0.48 → 1.0.49

package/mcp/termify-mcp-bundle.mjs

@@ -21474,6 +21474,29 @@ function loadConfigFile() {
   }
 }
 var _fileConfig = loadConfigFile();
+function resolveConfig(config2) {
+  if (config2.token) {
+    return {
+      token: config2.token,
+      apiUrl: config2.apiUrl || "http://localhost:3001"
+    };
+  }
+  if (!Array.isArray(config2.endpoints) || config2.endpoints.length === 0) {
+    return null;
+  }
+  const validEndpoints = config2.endpoints.filter((endpoint2) => {
+    return Boolean(endpoint2?.apiUrl && endpoint2?.token);
+  });
+  if (validEndpoints.length === 0) {
+    return null;
+  }
+  const activeEndpoint = config2.syncEndpoint ? validEndpoints.find((endpoint2) => endpoint2.name === config2.syncEndpoint) : void 0;
+  const endpoint = activeEndpoint || validEndpoints[0];
+  return {
+    token: endpoint.token,
+    apiUrl: endpoint.apiUrl
+  };
+}
 var TERMIFY_STATUS_URL = process.env.TERMIFY_STATUS_URL || "";
 var TERMINAL_ID = process.env.TERMIFY_TERMINAL_ID || "";
 var SESSION_ID = process.env.TERMIFY_SESSION_ID || "";
@@ -21481,10 +21504,11 @@ var _api = null;
 function getApi() {
   if (_api)
     return _api;
-  const token = process.env.TERMIFY_TOKEN || process.env.TERMIFY_API_KEY || _fileConfig.token || "";
+  const resolvedConfig = resolveConfig(_fileConfig);
+  const token = process.env.TERMIFY_TOKEN || process.env.TERMIFY_API_KEY || resolvedConfig?.token || "";
   if (!token)
     return null;
-  const url = process.env.TERMIFY_API_URL || _fileConfig.apiUrl || "http://localhost:3001";
+  const url = process.env.TERMIFY_API_URL || resolvedConfig?.apiUrl || "http://localhost:3001";
   _api = new TermifyApiService(url, token);
   return _api;
 }

package/package.json

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

package/scripts/postinstall.js

@@ -14,9 +14,9 @@
  * `termify-agent start` for faster npm install times. See src/setup.ts.
  */
 
-import { execSync, execFileSync } from 'child_process';
-import { createWriteStream, mkdirSync, chmodSync, existsSync, unlinkSync, copyFileSync, rmSync, readFileSync, writeFileSync, symlinkSync, lstatSync } from 'fs';
-import { join, dirname } from 'path';
+import { execSync } from 'child_process';
+import { createWriteStream, mkdirSync, chmodSync, existsSync, unlinkSync, copyFileSync, rmSync, readFileSync, readlinkSync, writeFileSync, symlinkSync, lstatSync } from 'fs';
+import { isAbsolute, join, dirname, resolve } from 'path';
 import { homedir, platform, arch } from 'os';
 import { get } from 'https';
 import { fileURLToPath } from 'url';
@@ -422,37 +422,100 @@ function downloadFile(url, dest, redirects = 0) {
 /**
  * Create /usr/local/bin/termify-agent so `sudo termify-agent` works.
  */
-function ensureGlobalSymlink() {
-  if (IS_WIN) return;
+function resolveCurrentPackageBinPath() {
+  const packagedBinPath = join(__dirname, '..', 'bin', 'termify-agent.js');
+  return existsSync(packagedBinPath) ? packagedBinPath : null;
+}
 
-  const target = '/usr/local/bin/termify-agent';
+function normalizeLinkTarget(target, linkTarget) {
+  return isAbsolute(linkTarget) ? linkTarget : resolve(dirname(target), linkTarget);
+}
+
+function isLegacyWrapperLink(linkTarget) {
+  return linkTarget.includes('/.termify/agent/');
+}
 
+function isLegacyWrapperFile(target) {
   try {
-    lstatSync(target);
-    console.log('[termify-agent] /usr/local/bin/termify-agent already exists, skipping.');
-    return;
+    const contents = readFileSync(target, 'utf8');
+    return contents.includes('TERMIFY_DIR=') && contents.includes('/agent/bin/termify-agent.js');
   } catch {
-    // Doesn't exist — good, we'll create it
+    return false;
   }
+}
 
-  let npmBinPath = null;
+export function detectGlobalWrapperState(target, desiredPath) {
   try {
-    npmBinPath = execFileSync('which', ['termify-agent'], { stdio: 'pipe', encoding: 'utf8' }).trim();
-  } catch {
-    npmBinPath = join(__dirname, '..', 'bin', 'termify-agent.js');
-    if (!existsSync(npmBinPath)) {
-      console.log('[termify-agent] Could not locate termify-agent binary for symlink.');
-      return;
+    const stat = lstatSync(target);
+
+    if (stat.isSymbolicLink()) {
+      const linkTarget = readlinkSync(target);
+      const normalizedTarget = normalizeLinkTarget(target, linkTarget);
+
+      if (desiredPath && normalizedTarget === desiredPath) {
+        return 'ready';
+      }
+
+      if (isLegacyWrapperLink(linkTarget) || isLegacyWrapperLink(normalizedTarget)) {
+        return 'legacy';
+      }
+
+      return 'conflict';
+    }
+
+    if (stat.isFile() && isLegacyWrapperFile(target)) {
+      return 'legacy';
+    }
+
+    return 'conflict';
+  } catch (error) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+      return 'missing';
     }
+
+    throw error;
   }
+}
 
-  if (!npmBinPath || npmBinPath === target) return;
+export function ensureGlobalSymlink(options = {}) {
+  if (IS_WIN) {
+    return { status: 'skipped', action: 'windows' };
+  }
+
+  const target = options.target || '/usr/local/bin/termify-agent';
+  const log = options.log || console.log;
+  const desiredPath = options.desiredPath || resolveCurrentPackageBinPath();
+
+  if (!desiredPath || !existsSync(desiredPath)) {
+    log('[termify-agent] Could not locate termify-agent binary for symlink.');
+    return { status: 'skipped', action: 'missing_bin' };
+  }
+
+  const wrapperState = detectGlobalWrapperState(target, desiredPath);
+  if (wrapperState === 'ready') {
+    log('[termify-agent] /usr/local/bin/termify-agent already points to the current npm install.');
+    return { status: 'ready', action: 'already_ready' };
+  }
+
+  if (wrapperState === 'conflict') {
+    log('[termify-agent] /usr/local/bin/termify-agent already exists, skipping.');
+    return { status: 'skipped', action: 'conflict' };
+  }
 
   try {
-    symlinkSync(npmBinPath, target);
-    console.log(`[termify-agent] Symlink created: ${target} \u2192 ${npmBinPath}`);
+    if (wrapperState === 'legacy') {
+      unlinkSync(target);
+    }
+
+    symlinkSync(desiredPath, target);
+    log(`[termify-agent] Symlink ${wrapperState === 'legacy' ? 'updated' : 'created'}: ${target} \u2192 ${desiredPath}`);
+    return {
+      status: 'ready',
+      action: wrapperState === 'legacy' ? 'replaced_legacy' : 'created',
+    };
   } catch {
-    console.log(`[termify-agent] Tip: run 'sudo ln -sf "${npmBinPath}" ${target}' to enable sudo access`);
+    log(`[termify-agent] Tip: run 'sudo ln -sf "${desiredPath}" ${target}' to enable sudo access`);
+    return { status: 'skipped', action: 'permission_denied' };
   }
 }
 
@@ -522,8 +585,8 @@ async function main() {
   // Step 5: Global symlink
   const s3 = createSpinner('Creating global symlink...');
   try {
-    ensureGlobalSymlink();
-    if (existsSync('/usr/local/bin/termify-agent')) {
+    const symlinkResult = ensureGlobalSymlink();
+    if (symlinkResult?.status === 'ready') {
       s3.succeed('Global symlink ready');
     } else {
       s3.warn(`Symlink skipped ${DIM}(run: sudo ln -sf $(which termify-agent) /usr/local/bin/)${RESET}`);
@@ -539,7 +602,9 @@ async function main() {
   console.log('');
 }
 
-main().catch((err) => {
-  console.warn(`\n  ${WARN} Postinstall warning: ${err.message}\n`);
-  process.exit(0);
-});
+if (process.argv[1] && resolve(process.argv[1]) === __filename) {
+  main().catch((err) => {
+    console.warn(`\n  ${WARN} Postinstall warning: ${err.message}\n`);
+    process.exit(0);
+  });
+}

package/scripts/postinstall.test.mjs

@@ -0,0 +1,96 @@
+import assert from 'node:assert/strict';
+import { 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';
+
+function makeTempDir() {
+  return mkdtempSync(join(tmpdir(), 'termify-agent-postinstall-'));
+}
+
+test('ensureGlobalSymlink replaces the legacy curl wrapper with the npm package bin', (t) => {
+  const tempDir = makeTempDir();
+  const target = join(tempDir, 'usr-local-bin-termify-agent');
+  const desiredDir = join(tempDir, 'package', 'bin');
+  const desiredPath = join(desiredDir, 'termify-agent.js');
+
+  t.after(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  mkdirSync(desiredDir, { recursive: true });
+  writeFileSync(desiredPath, '#!/usr/bin/env node\n');
+  writeFileSync(
+    target,
+    [
+      '#!/bin/sh',
+      'TERMIFY_DIR="$HOME/.termify"',
+      'NODE_BIN="$TERMIFY_DIR/node/bin/node"',
+      'exec "$NODE_BIN" "$TERMIFY_DIR/agent/bin/termify-agent.js" "$@"',
+      '',
+    ].join('\n')
+  );
+
+  assert.equal(detectGlobalWrapperState(target, desiredPath), 'legacy');
+
+  const result = ensureGlobalSymlink({
+    target,
+    desiredPath,
+    log: () => {},
+  });
+
+  assert.equal(result.status, 'ready');
+  assert.equal(result.action, 'replaced_legacy');
+  assert.equal(lstatSync(target).isSymbolicLink(), true);
+  assert.equal(resolve(dirname(target), readlinkSync(target)), desiredPath);
+});
+
+test('ensureGlobalSymlink does not overwrite a non-legacy existing target', (t) => {
+  const tempDir = makeTempDir();
+  const target = join(tempDir, 'usr-local-bin-termify-agent');
+  const desiredDir = join(tempDir, 'package', 'bin');
+  const desiredPath = join(desiredDir, 'termify-agent.js');
+  const customPath = join(tempDir, 'custom', 'termify-agent.js');
+
+  t.after(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  mkdirSync(desiredDir, { recursive: true });
+  mkdirSync(dirname(customPath), { recursive: true });
+  writeFileSync(desiredPath, '#!/usr/bin/env node\n');
+  writeFileSync(customPath, '#!/usr/bin/env node\n');
+  symlinkSync(customPath, target);
+
+  assert.equal(detectGlobalWrapperState(target, desiredPath), 'conflict');
+
+  const result = ensureGlobalSymlink({
+    target,
+    desiredPath,
+    log: () => {},
+  });
+
+  assert.equal(result.status, 'skipped');
+  assert.equal(result.action, 'conflict');
+  assert.equal(resolve(dirname(target), readlinkSync(target)), customPath);
+});
+
+test('detectGlobalWrapperState treats an up-to-date symlink as ready', (t) => {
+  const tempDir = makeTempDir();
+  const target = join(tempDir, 'usr-local-bin-termify-agent');
+  const desiredDir = join(tempDir, 'package', 'bin');
+  const desiredPath = join(desiredDir, 'termify-agent.js');
+
+  t.after(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  mkdirSync(desiredDir, { recursive: true });
+  writeFileSync(desiredPath, '#!/usr/bin/env node\n');
+  symlinkSync(desiredPath, target);
+
+  assert.equal(detectGlobalWrapperState(target, desiredPath), 'ready');
+  assert.equal(readFileSync(desiredPath, 'utf8'), '#!/usr/bin/env node\n');
+});