troxy-cli 1.29.2 → 1.29.4

package/src/tests/auth.test.js

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert';
 
-import { isOpenableUrl } from '../auth.js';
+import { isOpenableUrl, _codeInputStrategy } from '../auth.js';
 
 test('isOpenableUrl accepts plain https and rejects everything else (H4)', () => {
   assert.equal(isOpenableUrl('https://dash.troxy.io/cli?code=abc'), true);
@@ -25,3 +25,14 @@ test('isOpenableUrl accepts plain https and rejects everything else (H4)', () =>
     assert.equal(isOpenableUrl(bad), false, `should reject: ${String(bad)}`);
   }
 });
+
+test('_codeInputStrategy: a real TTY gets the masked raw-mode prompt', () => {
+  assert.equal(_codeInputStrategy(true), 'raw-tty');
+});
+
+test('_codeInputStrategy: no TTY falls back to a plain line read, never raw mode ' +
+     '(regression: process.stdin.setRawMode is not a function without a real TTY - ' +
+     'used to crash `troxy login` outright for a script, CI, or an agent\'s own shell)', () => {
+  assert.equal(_codeInputStrategy(false), 'line-read');
+  assert.equal(_codeInputStrategy(undefined), 'line-read');
+});

package/src/tests/claude-code-hook.test.js

@@ -17,7 +17,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import { patchClaudeCodeConfig, patchClaudeCodeHooks } from '../init.js';
+import { patchClaudeCodeConfig, patchClaudeCodeHooks, unpatchClaudeCodeConfig, unpatchClaudeCodeHooks } from '../init.js';
 
 let dir;
 beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-cc-')); });
@@ -71,6 +71,52 @@ describe('patchClaudeCodeConfig', () => {
   });
 });
 
+// Uninstall symmetry: removes the troxy entry from EVERY project in the
+// file, not just process.cwd() - `troxy init` may have run from several
+// project directories over time, each getting its own entry, and uninstall
+// has no reliable way to know which cwd(s) were ever used.
+describe('unpatchClaudeCodeConfig', () => {
+  const configPath = () => path.join(dir, '.claude.json');
+  const read = () => JSON.parse(fs.readFileSync(configPath(), 'utf8'));
+
+  it('removes the troxy entry from a single project', () => {
+    patchClaudeCodeConfig(configPath(), 'txy-abc', '/Users/x/proj');
+    unpatchClaudeCodeConfig(configPath());
+    const cfg = read();
+    assert.equal(cfg.projects['/Users/x/proj'].mcpServers.troxy, undefined);
+  });
+
+  it('removes it from every project that has one, in a single pass', () => {
+    patchClaudeCodeConfig(configPath(), 'txy-abc', '/Users/x/proj-a');
+    patchClaudeCodeConfig(configPath(), 'txy-abc', '/Users/x/proj-b');
+    unpatchClaudeCodeConfig(configPath());
+    const cfg = read();
+    assert.equal(cfg.projects['/Users/x/proj-a'].mcpServers.troxy, undefined);
+    assert.equal(cfg.projects['/Users/x/proj-b'].mcpServers.troxy, undefined);
+  });
+
+  it('leaves other tools\' mcpServers entries and unrelated project keys untouched', () => {
+    fs.writeFileSync(configPath(), JSON.stringify({
+      projects: { '/Users/x/proj': { allowedTools: ['Bash'], mcpServers: { someOtherTool: { command: 'x' } } } },
+    }));
+    patchClaudeCodeConfig(configPath(), 'txy-abc', '/Users/x/proj');
+    unpatchClaudeCodeConfig(configPath());
+    const cfg = read();
+    assert.deepEqual(cfg.projects['/Users/x/proj'].allowedTools, ['Bash']);
+    assert.ok(cfg.projects['/Users/x/proj'].mcpServers.someOtherTool);
+  });
+
+  it('does not throw and does not create a file when called against a non-existent config file', () => {
+    assert.doesNotThrow(() => unpatchClaudeCodeConfig(configPath()));
+    assert.equal(fs.existsSync(configPath()), false);
+  });
+
+  it('does not throw when the existing file is corrupted JSON', () => {
+    fs.writeFileSync(configPath(), '{ not json');
+    assert.doesNotThrow(() => unpatchClaudeCodeConfig(configPath()));
+  });
+});
+
 describe('patchClaudeCodeHooks', () => {
   const configPath = () => path.join(dir, 'settings.json');
   const read = () => JSON.parse(fs.readFileSync(configPath(), 'utf8'));
@@ -178,3 +224,52 @@ describe('patchClaudeCodeHooks: PreToolUse gate', () => {
     assert.equal(cfg.hooks.Stop[0].hooks[0].command, 'troxy hook-report');
   });
 });
+
+// Uninstall symmetry: removes exactly the Troxy-owned Stop/PreToolUse
+// entries (identified the same way patchClaudeCodeHooks itself finds them
+// to update in place - by command containing 'hook-report'/'pretooluse-hook'),
+// leaving any of the user's own unrelated hooks in the same file untouched.
+describe('unpatchClaudeCodeHooks', () => {
+  const configPath = () => path.join(dir, 'settings.json');
+  const read = () => JSON.parse(fs.readFileSync(configPath(), 'utf8'));
+
+  it('removes the Troxy Stop and PreToolUse entries', () => {
+    patchClaudeCodeHooks(configPath(), 'troxy hook-report', 'troxy pretooluse-hook');
+    unpatchClaudeCodeHooks(configPath());
+    const cfg = read();
+    assert.equal(cfg.hooks.Stop.length, 0);
+    assert.equal(cfg.hooks.PreToolUse.length, 0);
+  });
+
+  it("preserves the user's own unrelated Stop and PreToolUse hooks in the same file", () => {
+    fs.writeFileSync(configPath(), JSON.stringify({
+      hooks: {
+        Stop: [{ hooks: [{ type: 'command', command: 'my-own-script.sh' }] }],
+        PreToolUse: [{ matcher: 'Write', hooks: [{ type: 'command', command: 'validate.sh' }] }],
+      },
+    }));
+    patchClaudeCodeHooks(configPath(), 'troxy hook-report', 'troxy pretooluse-hook');
+    unpatchClaudeCodeHooks(configPath());
+    const cfg = read();
+    assert.equal(cfg.hooks.Stop.length, 1);
+    assert.equal(cfg.hooks.Stop[0].hooks[0].command, 'my-own-script.sh');
+    assert.equal(cfg.hooks.PreToolUse.length, 1);
+    assert.equal(cfg.hooks.PreToolUse[0].hooks[0].command, 'validate.sh');
+  });
+
+  it('does not throw and does not create a file when called against a non-existent settings file', () => {
+    assert.doesNotThrow(() => unpatchClaudeCodeHooks(configPath()));
+    assert.equal(fs.existsSync(configPath()), false);
+  });
+
+  it('does not throw when the existing file is corrupted JSON', () => {
+    fs.writeFileSync(configPath(), '{ not json');
+    assert.doesNotThrow(() => unpatchClaudeCodeHooks(configPath()));
+  });
+
+  it('is idempotent - calling twice is safe', () => {
+    patchClaudeCodeHooks(configPath(), 'troxy hook-report', 'troxy pretooluse-hook');
+    unpatchClaudeCodeHooks(configPath());
+    assert.doesNotThrow(() => unpatchClaudeCodeHooks(configPath()));
+  });
+});

package/src/tests/claude-code-proxy.test.js

@@ -14,7 +14,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import { patchClaudeCodeProxy, troxyModelProxyBaseUrl } from '../init.js';
+import { patchClaudeCodeProxy, unpatchClaudeCodeProxy, troxyModelProxyBaseUrl, migrateBaseUrlProxyToInterception } from '../init.js';
 
 let dir;
 beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-cc-proxy-')); });
@@ -88,3 +88,122 @@ describe('patchClaudeCodeProxy', () => {
     assert.doesNotThrow(() => patchClaudeCodeProxy(configPath(), KEY));
   });
 });
+
+// Uninstall symmetry (fail-open layer 6 of the Live Model Policy Enforcement
+// plan): before this existed, `troxy uninstall` deleted ~/.troxy but never
+// touched these three keys, so a machine that had them set kept routing
+// through a proxy that no longer existed.
+describe('unpatchClaudeCodeProxy', () => {
+  const configPath = () => path.join(dir, 'settings.json');
+  const read = () => JSON.parse(fs.readFileSync(configPath(), 'utf8'));
+  const KEY = 'txy-test-key-123';
+
+  it('removes exactly the three keys patchClaudeCodeProxy writes', () => {
+    patchClaudeCodeProxy(configPath(), KEY);
+    unpatchClaudeCodeProxy(configPath());
+    const cfg = read();
+    assert.equal(cfg.env.ANTHROPIC_BASE_URL, undefined);
+    assert.equal(cfg.env.ANTHROPIC_AUTH_TOKEN, undefined);
+    assert.equal(cfg.env.ENABLE_TOOL_SEARCH, undefined);
+  });
+
+  it('leaves unrelated env keys (e.g. the interception keys) and top-level keys untouched', () => {
+    fs.writeFileSync(configPath(), JSON.stringify({
+      env: { HTTPS_PROXY: 'http://127.0.0.1:48173', SOME_OTHER_VAR: 'keep-me' },
+      hooks: { Stop: [{ hooks: [{ command: 'x' }] }] },
+    }));
+    patchClaudeCodeProxy(configPath(), KEY);
+    unpatchClaudeCodeProxy(configPath());
+    const cfg = read();
+    assert.equal(cfg.env.HTTPS_PROXY, 'http://127.0.0.1:48173');
+    assert.equal(cfg.env.SOME_OTHER_VAR, 'keep-me');
+    assert.equal(cfg.hooks.Stop.length, 1);
+  });
+
+  it('does not throw and does not create a file when called against a non-existent settings file', () => {
+    assert.doesNotThrow(() => unpatchClaudeCodeProxy(configPath()));
+    assert.equal(fs.existsSync(configPath()), false);
+  });
+
+  it('does not throw when the existing file is corrupted JSON', () => {
+    fs.writeFileSync(configPath(), '{ not json');
+    assert.doesNotThrow(() => unpatchClaudeCodeProxy(configPath()));
+  });
+
+  it('is idempotent - calling twice is safe', () => {
+    patchClaudeCodeProxy(configPath(), KEY);
+    unpatchClaudeCodeProxy(configPath());
+    assert.doesNotThrow(() => unpatchClaudeCodeProxy(configPath()));
+  });
+});
+
+// New for the terminal-interception-passthrough plan (2026-09-08): a
+// machine that already ran `troxy init --proxy` has the old base-URL
+// substitution keys set, which is the live billing bug (terminal calls
+// silently charged to the org's own API key instead of the user's
+// subscription). This is the auto-migration step that removes them the
+// next time init/rotate-key/update runs, regardless of whether the user
+// then opts into interception.
+describe('migrateBaseUrlProxyToInterception', () => {
+  const configPath = () => path.join(dir, 'settings.json');
+  const read = () => JSON.parse(fs.readFileSync(configPath(), 'utf8'));
+  const KEY = 'txy-test-key-123';
+
+  it('returns false and does nothing when the file does not exist', () => {
+    assert.equal(migrateBaseUrlProxyToInterception(configPath()), false);
+    assert.equal(fs.existsSync(configPath()), false);
+  });
+
+  it('returns false and does nothing when neither old key is set', () => {
+    fs.writeFileSync(configPath(), JSON.stringify({ env: { SOME_OTHER_VAR: 'keep-me' } }));
+    assert.equal(migrateBaseUrlProxyToInterception(configPath()), false);
+    assert.equal(read().env.SOME_OTHER_VAR, 'keep-me');
+  });
+
+  it('returns true and removes all three base-URL-proxy keys when ANTHROPIC_BASE_URL is set', () => {
+    patchClaudeCodeProxy(configPath(), KEY);
+    assert.equal(migrateBaseUrlProxyToInterception(configPath()), true);
+    const cfg = read();
+    assert.equal(cfg.env.ANTHROPIC_BASE_URL, undefined);
+    assert.equal(cfg.env.ANTHROPIC_AUTH_TOKEN, undefined);
+    assert.equal(cfg.env.ENABLE_TOOL_SEARCH, undefined);
+  });
+
+  it('returns true when only ANTHROPIC_AUTH_TOKEN is set (partial/manually-edited state)', () => {
+    fs.writeFileSync(configPath(), JSON.stringify({ env: { ANTHROPIC_AUTH_TOKEN: 'txy-abc' } }));
+    assert.equal(migrateBaseUrlProxyToInterception(configPath()), true);
+    assert.equal(read().env.ANTHROPIC_AUTH_TOKEN, undefined);
+  });
+
+  it('does not touch a non-Troxy ANTHROPIC_BASE_URL/ANTHROPIC_AUTH_TOKEN (e.g. a user\'s own LiteLLM/Bedrock gateway)', () => {
+    fs.writeFileSync(configPath(), JSON.stringify({
+      env: { ANTHROPIC_BASE_URL: 'https://litellm.internal/v1', ANTHROPIC_AUTH_TOKEN: 'sk-my-own-key' },
+    }));
+    assert.equal(migrateBaseUrlProxyToInterception(configPath()), false);
+    const cfg = read();
+    assert.equal(cfg.env.ANTHROPIC_BASE_URL, 'https://litellm.internal/v1');
+    assert.equal(cfg.env.ANTHROPIC_AUTH_TOKEN, 'sk-my-own-key');
+  });
+
+  it('preserves unrelated env keys (e.g. interception keys already set) and top-level keys', () => {
+    fs.writeFileSync(configPath(), JSON.stringify({
+      env: { ANTHROPIC_BASE_URL: 'https://proxy.troxy.io', HTTPS_PROXY: 'http://127.0.0.1:48173' },
+      hooks: { Stop: [{ hooks: [{ command: 'x' }] }] },
+    }));
+    migrateBaseUrlProxyToInterception(configPath());
+    const cfg = read();
+    assert.equal(cfg.env.HTTPS_PROXY, 'http://127.0.0.1:48173');
+    assert.equal(cfg.hooks.Stop.length, 1);
+  });
+
+  it('does not throw when the existing file is corrupted JSON', () => {
+    fs.writeFileSync(configPath(), '{ not json');
+    assert.doesNotThrow(() => migrateBaseUrlProxyToInterception(configPath()));
+  });
+
+  it('is idempotent - calling twice is safe and returns false the second time', () => {
+    patchClaudeCodeProxy(configPath(), KEY);
+    assert.equal(migrateBaseUrlProxyToInterception(configPath()), true);
+    assert.equal(migrateBaseUrlProxyToInterception(configPath()), false);
+  });
+});

package/src/tests/daemon.test.js

@@ -0,0 +1,85 @@
+// daemon.js's startInterceptor() is thin orchestration over already-tested
+// pieces (createInterceptor, ensureInterceptionCerts, providers.js) - these
+// tests cover the wiring itself (it actually binds, it actually generates
+// certs on first run, a second call is idempotent), not the underlying
+// TLS/CA/routing behavior, which interceptor.test.js and tls-ca.test.js
+// already cover thoroughly.
+//
+// Port 0 (OS-assigned) is used everywhere except the EADDRINUSE test,
+// deliberately - node:test runs `it()` blocks within a file concurrently
+// by default, and a separate "probe a free port, close it, then bind that
+// same number" pattern across multiple concurrent tests races: two tests'
+// probes can receive the SAME OS-assigned ephemeral port in the gap before
+// either has actually bound it (confirmed live - this reproduced on every
+// run before switching to port 0). Binding directly with port 0 makes
+// "find a free port" and "bind it" one atomic step, which is the only way
+// to avoid that race entirely.
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import net from 'node:net';
+
+import { startInterceptor } from '../daemon.js';
+
+let dir;
+let servers = [];
+beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-daemon-')); servers = []; });
+afterEach(() => {
+  for (const s of servers) { try { s.close(); } catch {} }
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe('startInterceptor', () => {
+  it('starts and actually binds - Phase 1 always has at least the anthropic provider enabled', async () => {
+    const server = startInterceptor({ troxyDir: dir, port: 0 });
+    servers.push(server);
+    assert.ok(server, 'expected a server instance, got null');
+    await new Promise((resolve, reject) => {
+      server.on('listening', resolve);
+      server.on('error', reject);
+    });
+    assert.equal(server.listening, true);
+  });
+
+  it('generates the CA + leaf certificate files under the given troxyDir on first run', async () => {
+    const server = startInterceptor({ troxyDir: dir, port: 0 });
+    servers.push(server);
+    await new Promise((resolve, reject) => { server.on('listening', resolve); server.on('error', reject); });
+
+    assert.ok(fs.existsSync(path.join(dir, 'tls', 'troxy-local-ca.crt')));
+    assert.ok(fs.existsSync(path.join(dir, 'tls', 'leaf-api.anthropic.com.crt')));
+  });
+
+  it('a second call reuses the same CA rather than regenerating it', async () => {
+    const server1 = startInterceptor({ troxyDir: dir, port: 0 });
+    servers.push(server1);
+    await new Promise((resolve, reject) => { server1.on('listening', resolve); server1.on('error', reject); });
+    const firstCa = fs.readFileSync(path.join(dir, 'tls', 'troxy-local-ca.crt'), 'utf8');
+
+    const server2 = startInterceptor({ troxyDir: dir, port: 0 });
+    servers.push(server2);
+    await new Promise((resolve, reject) => { server2.on('listening', resolve); server2.on('error', reject); });
+    const secondCa = fs.readFileSync(path.join(dir, 'tls', 'troxy-local-ca.crt'), 'utf8');
+
+    assert.equal(secondCa, firstCa);
+  });
+
+  it('emits a clean EADDRINUSE error instead of crashing when the port is already taken', async () => {
+    // This one genuinely needs a specific, known port to collide on, so it
+    // can't use port 0 - occupies it directly with a plain server first,
+    // reading back the OS-assigned port from THAT bind (also atomic, no
+    // separate probe-then-close step).
+    const occupied = net.createServer();
+    servers.push(occupied);
+    await new Promise(r => occupied.listen(0, '127.0.0.1', r));
+    const port = occupied.address().port;
+
+    const server = startInterceptor({ troxyDir: dir, port });
+    servers.push(server);
+    const err = await new Promise((resolve) => { server.on('error', resolve); });
+    assert.equal(err.code, 'EADDRINUSE');
+  });
+});

package/src/tests/init-detection.test.js

@@ -0,0 +1,95 @@
+// hasClaudeDesktop() - Layer 3 of the Live Model Policy Enforcement plan.
+// Same technique tool_detect.js already uses for Cursor/Windsurf/etc: check
+// the app's own install directory, never a config file troxy itself might
+// have created (~/.claude.json and ~/.claude/settings.json are both created
+// lazily by troxy - their mere existence proves nothing about whether
+// Desktop is actually installed).
+//
+// Unlike tool_detect.js's `home` (cached at module load, forcing a
+// "set HOME before first import" trick), hasClaudeDesktop() reads
+// os.homedir() fresh on every call - so these tests just set process.env.HOME
+// per test, no import-order dance required.
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { hasClaudeDesktop } from '../init.js';
+
+let dir;
+let originalHome, originalLocalAppData, originalAppData;
+
+beforeEach(() => {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-desktop-detect-'));
+  originalHome = process.env.HOME;
+  originalLocalAppData = process.env.LOCALAPPDATA;
+  originalAppData = process.env.APPDATA;
+  process.env.HOME = dir;
+  delete process.env.LOCALAPPDATA;
+  delete process.env.APPDATA;
+});
+
+afterEach(() => {
+  process.env.HOME = originalHome;
+  if (originalLocalAppData === undefined) delete process.env.LOCALAPPDATA;
+  else process.env.LOCALAPPDATA = originalLocalAppData;
+  if (originalAppData === undefined) delete process.env.APPDATA;
+  else process.env.APPDATA = originalAppData;
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe('hasClaudeDesktop', () => {
+  it('reports false against a clean home dir with no app installed', () => {
+    assert.equal(hasClaudeDesktop(), false);
+  });
+
+  it('does NOT treat a troxy-created ~/.claude.json or ~/.claude/settings.json as evidence Desktop is installed', () => {
+    fs.writeFileSync(path.join(dir, '.claude.json'), '{}');
+    fs.mkdirSync(path.join(dir, '.claude'), { recursive: true });
+    fs.writeFileSync(path.join(dir, '.claude', 'settings.json'), '{}');
+    assert.equal(
+      hasClaudeDesktop(),
+      false,
+      'config files troxy itself creates must never look like Desktop being installed',
+    );
+  });
+
+  it("detects Desktop from ~/Library/Application Support/Claude (macOS)", () => {
+    fs.mkdirSync(path.join(dir, 'Library/Application Support/Claude'), { recursive: true });
+    assert.equal(hasClaudeDesktop(), true);
+  });
+
+  it("detects Desktop from ~/Applications/Claude.app (per-user Applications folder)", () => {
+    fs.mkdirSync(path.join(dir, 'Applications/Claude.app'), { recursive: true });
+    assert.equal(hasClaudeDesktop(), true);
+  });
+
+  it('detects Desktop from ~/.config/Claude (Linux)', () => {
+    fs.mkdirSync(path.join(dir, '.config/Claude'), { recursive: true });
+    assert.equal(hasClaudeDesktop(), true);
+  });
+
+  it('detects Desktop from %APPDATA%/Claude when APPDATA is set (Windows)', () => {
+    const appData = path.join(dir, 'AppData/Roaming');
+    fs.mkdirSync(path.join(appData, 'Claude'), { recursive: true });
+    process.env.APPDATA = appData;
+    assert.equal(hasClaudeDesktop(), true);
+  });
+
+  it('detects Desktop from %LOCALAPPDATA%/AnthropicClaude when LOCALAPPDATA is set (Windows)', () => {
+    const localAppData = path.join(dir, 'AppData/Local');
+    fs.mkdirSync(path.join(localAppData, 'AnthropicClaude'), { recursive: true });
+    process.env.LOCALAPPDATA = localAppData;
+    assert.equal(hasClaudeDesktop(), true);
+  });
+
+  it('never throws when a candidate path is unreadable/permission-denied rather than merely absent', () => {
+    // fs.existsSync itself never throws for a normal missing path, but the
+    // implementation wraps every check in try/catch specifically so a
+    // stranger failure mode (e.g. a permission-denied parent dir) degrades
+    // to "not detected" rather than crashing troxy init.
+    assert.doesNotThrow(() => hasClaudeDesktop());
+  });
+});

package/src/tests/install-service.test.js

@@ -0,0 +1,69 @@
+// Found live 2026-09-08: installService() resolved `which troxy`, silently
+// fell back to a guessed path (`/usr/local/bin/troxy`) when that failed, and
+// never checked either result actually existed before writing it into the
+// launchd plist / systemd unit and loading it - so a bad path always
+// "succeeded". verifyTroxyBinExists is the extracted, directly-testable
+// fix; installService (execSync/fs/launchctl-heavy, same as every other
+// platform-integration function in this file) stays covered by source
+// inspection, same convention as proxy-wiring.test.js.
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+import { verifyTroxyBinExists } from '../init.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const initSrc = readFileSync(join(__dirname, '..', 'init.js'), 'utf8');
+
+describe('verifyTroxyBinExists', () => {
+  it('does not throw when the given path exists', () => {
+    // process.execPath is Node's own binary - guaranteed to exist on any
+    // machine running this test, without depending on `troxy` itself being
+    // installed anywhere.
+    assert.doesNotThrow(() => verifyTroxyBinExists(process.execPath));
+  });
+
+  it('throws a clear, actionable error when the given path does not exist', () => {
+    assert.throws(
+      () => verifyTroxyBinExists('/definitely/not/a/real/path/troxy'),
+      /resolved troxy binary not found at \/definitely\/not\/a\/real\/path\/troxy.*npm link/s,
+    );
+  });
+});
+
+describe('installService: resolved-path verification (source inspection)', () => {
+  it('calls verifyTroxyBinExists(troxy) before branching on platform', () => {
+    const fnStart = initSrc.indexOf('function installService(apiKey, agentName)');
+    assert.ok(fnStart !== -1, 'installService not found');
+    const verifyIdx = initSrc.indexOf('verifyTroxyBinExists(troxy)', fnStart);
+    const linuxIdx = initSrc.indexOf("platform === 'linux'", fnStart);
+    const darwinIdx = initSrc.indexOf("platform === 'darwin'", fnStart);
+    assert.ok(verifyIdx !== -1, 'verifyTroxyBinExists(troxy) call not found inside installService');
+    assert.ok(verifyIdx < linuxIdx && verifyIdx < darwinIdx,
+      'the resolved path must be verified before either platform branch writes/loads a service pointing at it');
+  });
+});
+
+describe('installService: launchd log capture (source inspection)', () => {
+  it('darwin plist sets StandardOutPath and StandardErrorPath under ~/.troxy', () => {
+    const darwinIdx = initSrc.indexOf("platform === 'darwin'");
+    assert.ok(darwinIdx !== -1, "darwin branch not found");
+    const darwinBlock = initSrc.slice(darwinIdx, initSrc.indexOf("} else {", darwinIdx));
+    assert.match(darwinBlock, /StandardOutPath/, 'plist must declare StandardOutPath');
+    assert.match(darwinBlock, /StandardErrorPath/, 'plist must declare StandardErrorPath');
+    assert.match(darwinBlock, /daemon-out\.log/);
+    assert.match(darwinBlock, /daemon-err\.log/);
+  });
+
+  it('creates the ~/.troxy log directory before the plist is loaded', () => {
+    const darwinIdx = initSrc.indexOf("platform === 'darwin'");
+    const troxyDirIdx = initSrc.indexOf('const troxyDir', darwinIdx);
+    const mkdirIdx = initSrc.indexOf('fs.mkdirSync(troxyDir', darwinIdx);
+    const loadIdx = initSrc.indexOf('launchctl load', darwinIdx);
+    assert.ok(troxyDirIdx !== -1 && mkdirIdx !== -1 && loadIdx !== -1);
+    assert.ok(mkdirIdx < loadIdx, 'the log directory must be created before launchctl load runs');
+  });
+});