mirror of
https://github.com/tiennm99/ccs.git
synced 2026-07-16 04:18:05 +00:00
Tam Nhu Tran
b5ef06a4d5
ccs bar now spawns the web-server as a detached background process and exits immediately instead of hosting it in the foreground, so closing the terminal no longer takes the bar offline. Adds 'bar serve' (the long-lived host), 'bar stop', and 'bar status', and records ~/.ccs/bar/launch.json at install so the app can start the server without a shell PATH. Refs #1526
3029 lines
114 KiB
TypeScript
3029 lines
114 KiB
TypeScript
/**
|
|
* Tests for `ccs bar` command surface — Phase 3 TDD.
|
|
*
|
|
* Tests run FIRST per TDD mandate.
|
|
* Covers: subcommand routing, bar.json contract, floating-tag install,
|
|
* Info.plist version extraction, capability handshake compat, port-discovery
|
|
* fallback, uninstall, version, and verified review findings #8-#13.
|
|
*
|
|
* All network I/O and filesystem-home operations are mocked.
|
|
* Uses CCS_HOME env var for isolation — never touches real ~/.ccs.
|
|
*/
|
|
import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
|
|
import * as fs from 'fs';
|
|
import * as os from 'os';
|
|
import * as path from 'path';
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
let calls: string[] = [];
|
|
let consoleOutput: string[] = [];
|
|
let tempHome: string;
|
|
let originalCcsHome: string | undefined;
|
|
let originalConsoleLog: typeof console.log;
|
|
let originalConsoleError: typeof console.error;
|
|
|
|
function captureConsole(): void {
|
|
originalConsoleLog = console.log;
|
|
originalConsoleError = console.error;
|
|
console.log = (...args: unknown[]) => {
|
|
consoleOutput.push(args.map(String).join(' '));
|
|
};
|
|
console.error = (...args: unknown[]) => {
|
|
consoleOutput.push(args.map(String).join(' '));
|
|
};
|
|
}
|
|
|
|
function restoreConsole(): void {
|
|
console.log = originalConsoleLog;
|
|
console.error = originalConsoleError;
|
|
}
|
|
|
|
// Unique module cache-buster so bun:test picks up fresh mocks each describe block.
|
|
let moduleSeq = 0;
|
|
async function loadHandleBarCommand() {
|
|
moduleSeq++;
|
|
const mod = await import(`../../../src/commands/bar/index?test=${Date.now()}-${moduleSeq}`);
|
|
return mod.handleBarCommand as (args: string[]) => Promise<void>;
|
|
}
|
|
|
|
async function loadInstallSubcommand() {
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/install-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
return mod as {
|
|
handleBarInstall: (args: string[], deps?: Record<string, unknown>) => Promise<void>;
|
|
validateDownloadUrl: (url: string) => void;
|
|
};
|
|
}
|
|
|
|
async function loadLaunchSubcommand() {
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/launch-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
return mod as {
|
|
handleBarLaunch: (args: string[], deps?: Record<string, unknown>) => Promise<void>;
|
|
};
|
|
}
|
|
|
|
async function loadUninstallSubcommand() {
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/uninstall-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
return mod as {
|
|
handleBarUninstall: (args: string[], deps?: Record<string, unknown>) => Promise<void>;
|
|
};
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Setup / teardown
|
|
// ---------------------------------------------------------------------------
|
|
|
|
beforeEach(() => {
|
|
calls = [];
|
|
consoleOutput = [];
|
|
captureConsole();
|
|
|
|
tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-bar-test-'));
|
|
originalCcsHome = process.env.CCS_HOME;
|
|
process.env.CCS_HOME = tempHome;
|
|
});
|
|
|
|
afterEach(() => {
|
|
restoreConsole();
|
|
mock.restore();
|
|
|
|
if (originalCcsHome === undefined) {
|
|
delete process.env.CCS_HOME;
|
|
} else {
|
|
process.env.CCS_HOME = originalCcsHome;
|
|
}
|
|
|
|
// Clean up temp dir
|
|
try {
|
|
fs.rmSync(tempHome, { recursive: true, force: true });
|
|
} catch {
|
|
// ignore
|
|
}
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 1. Subcommand routing via handleBarCommand dispatcher
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar command dispatcher (index.ts)', () => {
|
|
beforeEach(() => {
|
|
mock.module('../../../src/commands/bar/launch-subcommand', () => ({
|
|
handleBarLaunch: async (args: string[]) => {
|
|
calls.push(`launch:${args.join(' ')}`);
|
|
},
|
|
}));
|
|
|
|
mock.module('../../../src/commands/bar/install-subcommand', () => ({
|
|
handleBarInstall: async (args: string[]) => {
|
|
calls.push(`install:${args.join(' ')}`);
|
|
},
|
|
}));
|
|
|
|
mock.module('../../../src/commands/bar/uninstall-subcommand', () => ({
|
|
handleBarUninstall: async (args: string[]) => {
|
|
calls.push(`uninstall:${args.join(' ')}`);
|
|
},
|
|
}));
|
|
|
|
mock.module('../../../src/commands/bar/version-subcommand', () => ({
|
|
handleBarVersion: async () => {
|
|
calls.push(`version:`);
|
|
},
|
|
}));
|
|
|
|
mock.module('../../../src/commands/bar/help-subcommand', () => ({
|
|
showHelp: async () => {
|
|
calls.push(`help:`);
|
|
},
|
|
}));
|
|
});
|
|
|
|
it('dispatches bare `ccs bar` to launch', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand([]);
|
|
expect(calls).toEqual(['launch:']);
|
|
});
|
|
|
|
it('dispatches `ccs bar launch` to launch subcommand', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['launch']);
|
|
expect(calls).toEqual(['launch:']);
|
|
});
|
|
|
|
it('dispatches `ccs bar install` to install subcommand', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['install']);
|
|
expect(calls).toEqual(['install:']);
|
|
});
|
|
|
|
it('dispatches `ccs bar uninstall` to uninstall subcommand', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['uninstall']);
|
|
expect(calls).toEqual(['uninstall:']);
|
|
});
|
|
|
|
it('dispatches `ccs bar --version` to version subcommand', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['--version']);
|
|
expect(calls).toEqual(['version:']);
|
|
});
|
|
|
|
it('dispatches `ccs bar version` to version subcommand', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['version']);
|
|
expect(calls).toEqual(['version:']);
|
|
});
|
|
|
|
it('passes remaining args to install subcommand', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['install', '--force']);
|
|
expect(calls).toEqual(['install:--force']);
|
|
});
|
|
|
|
it('treats unknown subcommands as an error and does not throw', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
// Should print help or error but not crash
|
|
await expect(handleBarCommand(['unknown-subcommand'])).resolves.toBeUndefined();
|
|
});
|
|
|
|
it('dispatches `ccs bar --help` to help subcommand and does not launch', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['--help']);
|
|
expect(calls).toEqual(['help:']);
|
|
expect(calls).not.toContain(expect.stringMatching(/^launch:/));
|
|
});
|
|
|
|
it('dispatches `ccs bar -h` to help subcommand and does not launch', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['-h']);
|
|
expect(calls).toEqual(['help:']);
|
|
expect(calls).not.toContain(expect.stringMatching(/^launch:/));
|
|
});
|
|
|
|
it('dispatches `ccs bar help` to help subcommand and does not hit unknown-subcommand error', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['help']);
|
|
expect(calls).toEqual(['help:']);
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).not.toMatch(/Unknown bar subcommand/);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 2. root-command-router registers `bar`
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('root-command-router registers bar', () => {
|
|
beforeEach(() => {
|
|
mock.module('../../../src/commands/bar/index', () => ({
|
|
handleBarCommand: async (args: string[]) => {
|
|
calls.push(`bar:${args.join(' ')}`);
|
|
},
|
|
}));
|
|
});
|
|
|
|
it('routes `ccs bar` through the root router', async () => {
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/root-command-router?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { tryHandleRootCommand } = mod;
|
|
|
|
const handled = await tryHandleRootCommand(['bar']);
|
|
expect(handled).toBe(true);
|
|
expect(calls).toEqual(['bar:']);
|
|
});
|
|
|
|
it('routes `ccs bar install` with args preserved', async () => {
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/root-command-router?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { tryHandleRootCommand } = mod;
|
|
|
|
await tryHandleRootCommand(['bar', 'install', '--force']);
|
|
expect(calls).toContain('bar:install --force');
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 3. bar.json contract written by launch
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Detached-model launch dep helpers (shared by tests in this describe block)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Build a minimal set of detached-model deps that behave like a successful
|
|
* launch for most tests. Individual tests override specific deps as needed.
|
|
*/
|
|
function makeDetachedDeps(ccsDir: string, port = 4242) {
|
|
return {
|
|
findRunningServer: async () => null,
|
|
getPort: async () => port,
|
|
spawnDetachedServer: (_p: number, _log: string) => { /* noop */ },
|
|
waitForServerLive: async (_url: string) => { /* live immediately */ },
|
|
writeLaunchDescriptor: () => { /* noop */ },
|
|
openApp: async (_appPath: string) => { /* noop */ },
|
|
getCcsDir: () => ccsDir,
|
|
appInstallPath: path.join(tempHome, 'Applications', 'CCS Bar.app'),
|
|
};
|
|
}
|
|
|
|
describe('bar.json contract (launch subcommand)', () => {
|
|
it('writes ~/.ccs/bar.json with correct shape when server starts', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
const { handleBarLaunch } = await loadLaunchSubcommand();
|
|
|
|
await handleBarLaunch([], {
|
|
...makeDetachedDeps(ccsDir, 4242),
|
|
openApp: async (_appPath: string) => {
|
|
calls.push(`open:${_appPath}`);
|
|
},
|
|
});
|
|
|
|
const barJsonPath = path.join(ccsDir, 'bar.json');
|
|
expect(fs.existsSync(barJsonPath)).toBe(true);
|
|
|
|
const barJson = JSON.parse(fs.readFileSync(barJsonPath, 'utf8')) as unknown;
|
|
expect(barJson).toMatchObject({
|
|
baseUrl: 'http://127.0.0.1:4242',
|
|
port: 4242,
|
|
authMode: 'loopback',
|
|
});
|
|
});
|
|
|
|
it('bar.json authMode is always "loopback" in v1', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
const { handleBarLaunch } = await loadLaunchSubcommand();
|
|
|
|
await handleBarLaunch([], makeDetachedDeps(ccsDir, 9000));
|
|
|
|
const barJson = JSON.parse(fs.readFileSync(path.join(ccsDir, 'bar.json'), 'utf8')) as {
|
|
authMode: string;
|
|
};
|
|
expect(barJson.authMode).toBe('loopback');
|
|
});
|
|
|
|
it('prints guidance when app is not installed', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
const { handleBarLaunch } = await loadLaunchSubcommand();
|
|
|
|
// App doesn't exist at appInstallPath — openApp throws so degraded path runs.
|
|
const nonExistentApp = path.join(tempHome, 'Applications', 'CCS Bar.app');
|
|
|
|
await handleBarLaunch([], {
|
|
...makeDetachedDeps(ccsDir, 3000),
|
|
openApp: async () => {
|
|
throw new Error('App not found');
|
|
},
|
|
appInstallPath: nonExistentApp,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Should suggest installation
|
|
expect(allOutput.toLowerCase()).toMatch(/install|not found|ccs bar install/i);
|
|
});
|
|
|
|
it('writes bar.json even when open fails (degraded path)', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
const { handleBarLaunch } = await loadLaunchSubcommand();
|
|
|
|
await handleBarLaunch([], {
|
|
...makeDetachedDeps(ccsDir, 3001),
|
|
openApp: async () => {
|
|
throw new Error('open failed');
|
|
},
|
|
});
|
|
|
|
// bar.json should still be written despite open failure
|
|
const barJsonPath = path.join(ccsDir, 'bar.json');
|
|
expect(fs.existsSync(barJsonPath)).toBe(true);
|
|
});
|
|
|
|
it('prints degraded-path warning when spawnDetachedServer throws', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
const { handleBarLaunch } = await loadLaunchSubcommand();
|
|
|
|
await handleBarLaunch([], {
|
|
...makeDetachedDeps(ccsDir, 3000),
|
|
spawnDetachedServer: () => {
|
|
throw new Error('spawn failed');
|
|
},
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput.toLowerCase()).toMatch(/error|failed|could not|unable/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 4. install subcommand — floating tag + Info.plist version + compat handshake
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install subcommand', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
const FAKE_VERSION = '1.2.3';
|
|
|
|
/** Create the fake CCS Bar.app in appsDir so the post-extract assertion passes. */
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
calls.push('download');
|
|
};
|
|
}
|
|
|
|
it('resolves the floating ccs-bar-latest tag (not exact CLI version)', async () => {
|
|
const fetchedUrls: string[] = [];
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async (tag: string, _asset: string) => {
|
|
fetchedUrls.push(tag);
|
|
return { downloadUrl: FAKE_DOWNLOAD_URL };
|
|
},
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async (_baseUrl: string) => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
// Must use the floating tag, NOT the CLI version
|
|
expect(fetchedUrls).toContain('ccs-bar-latest');
|
|
expect(fetchedUrls).not.toContain(expect.stringMatching(/^\d+\.\d+\.\d+$/));
|
|
});
|
|
|
|
it('pins the Info.plist version (not tag name) to ~/.ccs/bar/.version', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => ccsDir,
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const versionFile = path.join(ccsDir, 'bar', '.version');
|
|
expect(fs.existsSync(versionFile)).toBe(true);
|
|
expect(fs.readFileSync(versionFile, 'utf8').trim()).toBe(FAKE_VERSION);
|
|
});
|
|
|
|
it('calls /api/bar/summary for compat handshake after install', async () => {
|
|
const compatCalls: string[] = [];
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async (baseUrl: string) => {
|
|
compatCalls.push(baseUrl);
|
|
return { compatible: true, reason: 'ok' };
|
|
},
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
expect(compatCalls.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('does not hard-fail when compat returns no-bar-api', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await expect(
|
|
handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: false, reason: 'no-bar-api' }),
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
})
|
|
).resolves.toBeUndefined(); // does not throw
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput.toLowerCase()).toMatch(/warn|api|update/i);
|
|
});
|
|
|
|
it('prints xattr/Gatekeeper note for ad-hoc builds', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Inject clearQuarantine returning false so the fallback xattr guidance is
|
|
// always printed regardless of host platform (/usr/bin/xattr availability).
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
clearQuarantine: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Must mention either right-click or xattr quarantine command
|
|
expect(allOutput).toMatch(/xattr|right-click|quarantine/i);
|
|
});
|
|
|
|
it('does not overwrite ~/Applications if download fails', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await expect(
|
|
handleBarInstall([], {
|
|
fetchReleaseAsset: async () => {
|
|
throw new Error('network error');
|
|
},
|
|
downloadAndExtract: async () => {
|
|
/* noop */
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
})
|
|
).resolves.toBeUndefined(); // should not throw
|
|
|
|
// Apps dir should not be touched
|
|
expect(fs.existsSync(path.join(appsDir, 'CCS Bar.app'))).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 4a. Finding #8 — redirect-following download (mock 302 then 200 via deps)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: redirect-following download (#8)', () => {
|
|
const REDIRECT_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
const FINAL_URL = 'https://objects.githubusercontent.com/download/CCS-Bar.app.zip';
|
|
const FAKE_VERSION = '1.0.0';
|
|
|
|
it('succeeds when downloadAndExtract follows a 302 redirect to githubusercontent', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const urlsRequested: string[] = [];
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Simulate a downloader that internally follows a redirect (302 -> 200).
|
|
// The dep mock receives the initial URL and resolves to the final content.
|
|
const redirectFollowingExtract = async (url: string, dest: string) => {
|
|
urlsRequested.push(url);
|
|
// Simulate: original URL would 302 to FINAL_URL; mock follows it and succeeds.
|
|
if (url !== REDIRECT_URL) {
|
|
throw new Error(`Unexpected URL: ${url}`);
|
|
}
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: REDIRECT_URL,
|
|
}),
|
|
downloadAndExtract: redirectFollowingExtract,
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
// The download should have been attempted with the original URL
|
|
expect(urlsRequested).toContain(REDIRECT_URL);
|
|
// No error in output
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).not.toMatch(/\[X\]/);
|
|
expect(allOutput).toMatch(/\[OK\]/);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 4b. Finding #11 — HTTP statusCode != 200 throws descriptive error
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: HTTP status code validation (#11)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
it('reports descriptive error when downloadAndExtract throws on non-200', async () => {
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Simulate a downloader that respects status codes and throws on 403.
|
|
const statusCheckingExtract = async (url: string, _dest: string) => {
|
|
throw new Error(`Download failed: HTTP 403 for ${url}`);
|
|
};
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: FAKE_DOWNLOAD_URL,
|
|
}),
|
|
downloadAndExtract: statusCheckingExtract,
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.0.0',
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => path.join(tempHome, 'Applications'),
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Should surface the HTTP status in the output
|
|
expect(allOutput).toMatch(/403|Download failed/i);
|
|
expect(allOutput).toMatch(/\[X\]/);
|
|
});
|
|
|
|
it('reports descriptive error on 404 (asset not found)', async () => {
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: FAKE_DOWNLOAD_URL,
|
|
}),
|
|
downloadAndExtract: async (_url) => {
|
|
throw new Error(`Download failed: HTTP 404 for ${_url}`);
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.0.0',
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => path.join(tempHome, 'Applications'),
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/404|Download failed/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 4c. Finding #9 — host allowlist rejects non-github URLs
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: host allowlist validation (#9)', () => {
|
|
it('validateDownloadUrl accepts github.com URLs', async () => {
|
|
const { validateDownloadUrl } = await loadInstallSubcommand();
|
|
expect(() =>
|
|
validateDownloadUrl('https://github.com/kaitranntt/ccs/releases/download/tag/CCS-Bar.app.zip')
|
|
).not.toThrow();
|
|
});
|
|
|
|
it('validateDownloadUrl accepts objects.githubusercontent.com URLs', async () => {
|
|
const { validateDownloadUrl } = await loadInstallSubcommand();
|
|
expect(() =>
|
|
validateDownloadUrl('https://objects.githubusercontent.com/some/path/CCS-Bar.app.zip')
|
|
).not.toThrow();
|
|
});
|
|
|
|
it('validateDownloadUrl accepts *.githubusercontent.com wildcard', async () => {
|
|
const { validateDownloadUrl } = await loadInstallSubcommand();
|
|
expect(() =>
|
|
validateDownloadUrl('https://raw.githubusercontent.com/some/path/file.zip')
|
|
).not.toThrow();
|
|
});
|
|
|
|
it('validateDownloadUrl rejects http:// (non-HTTPS)', async () => {
|
|
const { validateDownloadUrl } = await loadInstallSubcommand();
|
|
expect(() =>
|
|
validateDownloadUrl('http://github.com/kaitranntt/ccs/releases/download/tag/file.zip')
|
|
).toThrow(/HTTPS|https/i);
|
|
});
|
|
|
|
it('validateDownloadUrl rejects untrusted hostnames', async () => {
|
|
const { validateDownloadUrl } = await loadInstallSubcommand();
|
|
expect(() => validateDownloadUrl('https://evil.example.com/CCS-Bar.app.zip')).toThrow(
|
|
/allowlist|trusted/i
|
|
);
|
|
});
|
|
|
|
it('validateDownloadUrl rejects a URL that looks like github but is not', async () => {
|
|
const { validateDownloadUrl } = await loadInstallSubcommand();
|
|
// A domain that ends in github.com.attacker.com must be rejected
|
|
expect(() => validateDownloadUrl('https://github.com.attacker.com/download/file.zip')).toThrow(
|
|
/allowlist|trusted/i
|
|
);
|
|
});
|
|
|
|
it('handleBarInstall surfaces a clear error for non-github download URLs', async () => {
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: 'https://evil.example.com/CCS-Bar.app.zip',
|
|
}),
|
|
// downloadAndExtract is the production default; it calls validateDownloadUrl internally.
|
|
// We pass a test-double that applies the same validation.
|
|
downloadAndExtract: async (url: string, _dest: string) => {
|
|
// Inline the validation that the production code runs.
|
|
const { validateDownloadUrl } = await loadInstallSubcommand();
|
|
validateDownloadUrl(url);
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.0.0',
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => path.join(tempHome, 'Applications'),
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Must report download/extraction failure with a clear [X] marker.
|
|
expect(allOutput).toMatch(/\[X\]/);
|
|
expect(allOutput.toLowerCase()).toMatch(/download|extraction|failed/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 4d. Compat capability handshake (replaces old major-version check)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: compat capability handshake', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
}
|
|
|
|
it('verifyCompat receives only baseUrl (no installedVersion param)', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const capturedArgs: Array<{ baseUrl: string }> = [];
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async (baseUrl: string) => {
|
|
capturedArgs.push({ baseUrl });
|
|
return { compatible: true, reason: 'ok' };
|
|
},
|
|
readAppBundleVersion: (_appPath: string) => '1.4.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
expect(capturedArgs.length).toBe(1);
|
|
// verifyCompat receives only one argument (baseUrl)
|
|
expect(capturedArgs[0].baseUrl).toMatch(/http/);
|
|
});
|
|
|
|
it('prints [OK] server bar API reachable when compat returns ok', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.4.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[OK\].*[Ss]erver bar API/);
|
|
// Must NOT print any mismatch warning
|
|
expect(allOutput).not.toMatch(/mismatch/i);
|
|
});
|
|
|
|
it('warns with actionable message when compat returns no-bar-api (404)', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: false, reason: 'no-bar-api' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.4.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[!\]/);
|
|
// Must mention the bar API and instruct the user to update CCS
|
|
expect(allOutput.toLowerCase()).toMatch(/bar api|\/api\/bar\/summary/i);
|
|
expect(allOutput.toLowerCase()).toMatch(/update ccs/i);
|
|
});
|
|
|
|
it('soft-warns (not crash) when compat returns unreachable', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: false, reason: 'unreachable' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.4.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Should warn rather than print [OK] compat confirmed
|
|
expect(allOutput).not.toMatch(/\[OK\].*[Cc]ompat/);
|
|
expect(allOutput).toMatch(/\[!\].*[Cc]ould not verify|server may not be running/i);
|
|
});
|
|
|
|
it('install never hard-fails due to compat failure', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await expect(
|
|
handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => {
|
|
throw new Error('network explosion');
|
|
},
|
|
readAppBundleVersion: (_appPath: string) => '1.4.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
})
|
|
).resolves.toBeUndefined();
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 4e. Finding #12 — post-extract CCS Bar.app existence assertion
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: post-extract app-exists assertion (#12)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
it('prints [OK] only when CCS Bar.app exists after extraction', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Correctly places CCS Bar.app in dest.
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: FAKE_DOWNLOAD_URL,
|
|
}),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.0.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[OK\].*CCS Bar/);
|
|
expect(allOutput).not.toMatch(/\[X\]/);
|
|
});
|
|
|
|
it('reports [X] and lists extracted files when CCS Bar.app is absent after extraction', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Extraction "succeeds" but places wrong file name.
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: FAKE_DOWNLOAD_URL,
|
|
}),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
// Places a wrongly-named artifact (simulates a bad archive).
|
|
fs.mkdirSync(dest, { recursive: true });
|
|
fs.writeFileSync(path.join(dest, 'WrongName.app'), 'dummy');
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.0.0',
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[X\]/);
|
|
// Should mention the missing app name
|
|
expect(allOutput).toMatch(/CCS Bar\.app/);
|
|
});
|
|
|
|
it('does not print xattr guidance when app is missing after extraction', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: FAKE_DOWNLOAD_URL,
|
|
}),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
// Nothing extracted
|
|
fs.mkdirSync(dest, { recursive: true });
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.0.0',
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// xattr note should NOT appear if install didn't succeed
|
|
expect(allOutput).not.toMatch(/xattr.*quarantine/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 4h. Regression: version source of truth — Info.plist, not tag_name
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: Info.plist version extraction regression tests', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
}
|
|
|
|
it('output never contains "vccs-bar-latest" when release tag is floating', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
// readAppBundleVersion returns the real version from Info.plist
|
|
readAppBundleVersion: (_appPath: string) => '1.4.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Must never print the floating tag as a version string
|
|
expect(allOutput).not.toMatch(/vccs-bar-latest/i);
|
|
// Must print the actual plist version
|
|
expect(allOutput).toMatch(/1\.4\.0/);
|
|
});
|
|
|
|
it('pins Info.plist version (1.4.0) to .version file, not the tag name', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => '1.4.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => ccsDir,
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const versionFile = path.join(ccsDir, 'bar', '.version');
|
|
expect(fs.existsSync(versionFile)).toBe(true);
|
|
const pinned = fs.readFileSync(versionFile, 'utf8').trim();
|
|
// Must be the plist value, not the floating tag
|
|
expect(pinned).toBe('1.4.0');
|
|
expect(pinned).not.toMatch(/ccs-bar-latest/i);
|
|
});
|
|
|
|
it('no pin write and ASCII notice when readAppBundleVersion returns null', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
// Unreadable Info.plist — returns null
|
|
readAppBundleVersion: (_appPath: string) => null,
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => ccsDir,
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
// No pin written
|
|
const versionFile = path.join(ccsDir, 'bar', '.version');
|
|
expect(fs.existsSync(versionFile)).toBe(false);
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// ASCII notice must appear
|
|
expect(allOutput).toMatch(/\[!\].*Info\.plist/i);
|
|
// Install itself must still succeed (no [X])
|
|
expect(allOutput).toMatch(/\[OK\].*CCS Bar/);
|
|
// No crash — test reaches here
|
|
});
|
|
|
|
it('defaultReadAppBundleVersion: extracts CFBundleShortVersionString from XML plist fixture', async () => {
|
|
// Test the default implementation directly using a temp file.
|
|
// We import the real module (not a mock) to access the default implementation.
|
|
// Because the module only exports handleBarInstall and validateDownloadUrl,
|
|
// we exercise the default via handleBarInstall without mocking readAppBundleVersion.
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const appPath = path.join(appsDir, 'CCS Bar.app');
|
|
|
|
// Create a real Info.plist fixture inside the fake .app bundle
|
|
const contentsDir = path.join(appPath, 'Contents');
|
|
fs.mkdirSync(contentsDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(contentsDir, '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>CFBundleIdentifier</key>
|
|
<string>com.kaitranntt.CCSBar</string>
|
|
<key>CFBundleShortVersionString</key>
|
|
<string>2.7.1</string>
|
|
<key>CFBundleVersion</key>
|
|
<string>271</string>
|
|
</dict>
|
|
</plist>`
|
|
);
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Use production readAppBundleVersion (omit from deps so default is used).
|
|
// downloadAndExtract must recreate the bundle because the stale-reinstall guard
|
|
// removes the pre-seeded app before extraction.
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl:
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip',
|
|
}),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
// Recreate the bundle with its Info.plist fixture after the old bundle is removed.
|
|
const contentsOut = path.join(dest, 'CCS Bar.app', 'Contents');
|
|
fs.mkdirSync(contentsOut, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(contentsOut, '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>CFBundleIdentifier</key>
|
|
<string>com.kaitranntt.CCSBar</string>
|
|
<key>CFBundleShortVersionString</key>
|
|
<string>2.7.1</string>
|
|
<key>CFBundleVersion</key>
|
|
<string>271</string>
|
|
</dict>
|
|
</plist>`
|
|
);
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
// readAppBundleVersion intentionally omitted → uses production default
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => ccsDir,
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const versionFile = path.join(ccsDir, 'bar', '.version');
|
|
expect(fs.existsSync(versionFile)).toBe(true);
|
|
expect(fs.readFileSync(versionFile, 'utf8').trim()).toBe('2.7.1');
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/2\.7\.1/);
|
|
});
|
|
|
|
it('defaultReadAppBundleVersion: returns null when Info.plist is missing', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const appPath = path.join(appsDir, 'CCS Bar.app');
|
|
|
|
// Create app bundle WITHOUT Info.plist
|
|
fs.mkdirSync(appPath, { recursive: true });
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// downloadAndExtract must recreate the bundle (without Info.plist) after the
|
|
// stale-reinstall guard removes the pre-seeded app.
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl:
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip',
|
|
}),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
// Recreate bare bundle — no Info.plist, matching the test's intent.
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
// readAppBundleVersion omitted → uses production default
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => ccsDir,
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
// No pin because plist is missing
|
|
const versionFile = path.join(ccsDir, 'bar', '.version');
|
|
expect(fs.existsSync(versionFile)).toBe(false);
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Should emit the ASCII notice
|
|
expect(allOutput).toMatch(/\[!\].*Info\.plist/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 5. Port discovery fallback
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('port discovery', () => {
|
|
it('reads port from existing bar.json when present', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
const barJson = { baseUrl: 'http://127.0.0.1:5555', port: 5555, authMode: 'loopback' };
|
|
fs.writeFileSync(path.join(ccsDir, 'bar.json'), JSON.stringify(barJson));
|
|
|
|
// Import the port-discovery utility from the bar module
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/launch-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { resolveBarPort } = mod as { resolveBarPort?: (ccsDir: string) => number | null };
|
|
|
|
if (resolveBarPort) {
|
|
const port = resolveBarPort(ccsDir);
|
|
expect(port).toBe(5555);
|
|
}
|
|
// If resolveBarPort is not exported separately, the behavior is tested through handleBarLaunch
|
|
});
|
|
|
|
it('returns null when bar.json is absent', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
// No bar.json written
|
|
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/launch-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { resolveBarPort } = mod as { resolveBarPort?: (ccsDir: string) => number | null };
|
|
|
|
if (resolveBarPort) {
|
|
const port = resolveBarPort(ccsDir);
|
|
expect(port).toBeNull();
|
|
}
|
|
});
|
|
|
|
it('returns null when bar.json is malformed', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
fs.writeFileSync(path.join(ccsDir, 'bar.json'), 'NOT_JSON{{{');
|
|
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/launch-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { resolveBarPort } = mod as { resolveBarPort?: (ccsDir: string) => number | null };
|
|
|
|
if (resolveBarPort) {
|
|
const port = resolveBarPort(ccsDir);
|
|
expect(port).toBeNull();
|
|
}
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 6. uninstall subcommand
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('uninstall subcommand', () => {
|
|
it('removes the app and clears the version pin', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
const barDir = path.join(ccsDir, 'bar');
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const appPath = path.join(appsDir, 'CCS Bar.app');
|
|
|
|
fs.mkdirSync(barDir, { recursive: true });
|
|
fs.mkdirSync(appPath, { recursive: true }); // fake .app bundle (it's a dir on macOS)
|
|
fs.writeFileSync(path.join(barDir, '.version'), '1.0.0');
|
|
|
|
const { handleBarUninstall } = await loadUninstallSubcommand();
|
|
|
|
await handleBarUninstall([], {
|
|
getCcsDir: () => ccsDir,
|
|
getAppsDir: () => appsDir,
|
|
appName: 'CCS Bar.app',
|
|
});
|
|
|
|
expect(fs.existsSync(appPath)).toBe(false);
|
|
expect(fs.existsSync(path.join(barDir, '.version'))).toBe(false);
|
|
});
|
|
|
|
it('is a no-op and does not throw when app is not installed', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
const { handleBarUninstall } = await loadUninstallSubcommand();
|
|
|
|
await expect(
|
|
handleBarUninstall([], {
|
|
getCcsDir: () => ccsDir,
|
|
getAppsDir: () => path.join(tempHome, 'Applications'),
|
|
appName: 'CCS Bar.app',
|
|
})
|
|
).resolves.toBeUndefined();
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 7. version subcommand — Finding #13: unambiguous CLI vs Bar app labels
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('version subcommand', () => {
|
|
it('prints the CCS version and exits cleanly', async () => {
|
|
let exitCode: number | undefined;
|
|
const origExit = process.exit;
|
|
process.exit = ((code?: number) => {
|
|
exitCode = code ?? 0;
|
|
}) as typeof process.exit;
|
|
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/version-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { handleBarVersion } = mod as { handleBarVersion: () => Promise<void> };
|
|
|
|
await handleBarVersion();
|
|
|
|
process.exit = origExit;
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Should mention "bar" and a version string
|
|
expect(allOutput.toLowerCase()).toMatch(/bar|ccs/i);
|
|
expect(allOutput).toMatch(/\d+\.\d+/);
|
|
expect(exitCode).toBe(0);
|
|
});
|
|
|
|
it('labels the CLI version unambiguously as CCS CLI (not CCS Bar)', async () => {
|
|
// Finding #13: line must say "CCS CLI v..." not just "CCS Bar v..."
|
|
let exitCode: number | undefined;
|
|
const origExit = process.exit;
|
|
process.exit = ((code?: number) => {
|
|
exitCode = code ?? 0;
|
|
}) as typeof process.exit;
|
|
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/version-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { handleBarVersion } = mod as { handleBarVersion: () => Promise<void> };
|
|
|
|
await handleBarVersion();
|
|
|
|
process.exit = origExit;
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Must include a line explicitly identifying the CLI version
|
|
expect(allOutput).toMatch(/CCS CLI v\d+/);
|
|
expect(exitCode).toBe(0);
|
|
});
|
|
|
|
it('labels the Bar app version separately from the CLI version', async () => {
|
|
// Finding #13: when Bar app is installed, its version must be on a separate labeled line
|
|
let exitCode: number | undefined;
|
|
const origExit = process.exit;
|
|
process.exit = ((code?: number) => {
|
|
exitCode = code ?? 0;
|
|
}) as typeof process.exit;
|
|
|
|
// getCcsDir() with CCS_HOME=tempHome returns tempHome/.ccs
|
|
// so the bar version file lives at tempHome/.ccs/bar/.version
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
const barDir = path.join(ccsDir, 'bar');
|
|
fs.mkdirSync(barDir, { recursive: true });
|
|
fs.writeFileSync(path.join(barDir, '.version'), '9.8.7');
|
|
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/version-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { handleBarVersion } = mod as { handleBarVersion: () => Promise<void> };
|
|
|
|
await handleBarVersion();
|
|
|
|
process.exit = origExit;
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// CLI version line
|
|
expect(allOutput).toMatch(/CCS CLI v\d+/);
|
|
// Bar app version line — must say "CCS Bar app: v..." not just "CCS Bar v..."
|
|
expect(allOutput).toMatch(/CCS Bar app: v9\.8\.7/);
|
|
expect(exitCode).toBe(0);
|
|
});
|
|
|
|
it('prints not-installed guidance for Bar app when version file is absent', async () => {
|
|
let exitCode: number | undefined;
|
|
const origExit = process.exit;
|
|
process.exit = ((code?: number) => {
|
|
exitCode = code ?? 0;
|
|
}) as typeof process.exit;
|
|
|
|
// No bar version file written — tempHome/.ccs/bar/.version absent
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/version-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { handleBarVersion } = mod as { handleBarVersion: () => Promise<void> };
|
|
|
|
await handleBarVersion();
|
|
|
|
process.exit = origExit;
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/CCS CLI v\d+/);
|
|
expect(allOutput.toLowerCase()).toMatch(/not installed|ccs bar install/i);
|
|
expect(exitCode).toBe(0);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 4f. Fix #6 — redirect host bypass: every hop is re-validated
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: redirect host re-validation (fix #6)', () => {
|
|
const INITIAL_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
const EVIL_REDIRECT_URL = 'https://evil.example.com/CCS-Bar.app.zip';
|
|
const FAKE_VERSION = '1.0.0';
|
|
|
|
it('rejects a download when a redirect leads to an untrusted host', async () => {
|
|
// Simulate a downloadAndExtract that follows a redirect to an untrusted host
|
|
// and validates each hop (the production fix). The mock replicates the fix logic.
|
|
const { handleBarInstall, validateDownloadUrl } = await loadInstallSubcommand();
|
|
|
|
const redirectFollowingExtract = async (url: string, _dest: string) => {
|
|
// Validate initial URL
|
|
validateDownloadUrl(url);
|
|
// Simulate a 302 to an evil host — production code re-validates Location
|
|
validateDownloadUrl(EVIL_REDIRECT_URL); // should throw
|
|
};
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: INITIAL_URL,
|
|
}),
|
|
downloadAndExtract: redirectFollowingExtract,
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => path.join(tempHome, 'Applications'),
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// The validation error should surface as a download/extraction failure
|
|
expect(allOutput).toMatch(/\[X\]/);
|
|
expect(allOutput.toLowerCase()).toMatch(/download|extraction|failed/i);
|
|
});
|
|
|
|
it('validateDownloadUrl blocks redirect targets with untrusted hostnames', async () => {
|
|
const { validateDownloadUrl } = await loadInstallSubcommand();
|
|
|
|
// The redirect target must be rejected just like any initial URL
|
|
expect(() => validateDownloadUrl(EVIL_REDIRECT_URL)).toThrow(/allowlist|trusted/i);
|
|
});
|
|
|
|
it('validateDownloadUrl allows the expected redirect target (githubusercontent.com)', async () => {
|
|
const { validateDownloadUrl } = await loadInstallSubcommand();
|
|
const legitimateRedirect = 'https://objects.githubusercontent.com/file/CCS-Bar.app.zip';
|
|
expect(() => validateDownloadUrl(legitimateRedirect)).not.toThrow();
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// 4g. Fix #14 — zip-slip guard: reject archives with traversal entries
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: zip-slip guard (fix #14)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
const FAKE_VERSION = '1.0.0';
|
|
|
|
it('rejects download when downloadAndExtract detects a zip-slip entry', async () => {
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Simulate an extractor that detects a zip-slip entry and throws
|
|
const zipSlipExtract = async (_url: string, _dest: string) => {
|
|
throw new Error(
|
|
'Zip-slip detected: archive entry "../../../evil" contains a path traversal component. Refusing to extract.'
|
|
);
|
|
};
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: FAKE_DOWNLOAD_URL,
|
|
}),
|
|
downloadAndExtract: zipSlipExtract,
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => path.join(tempHome, 'Applications'),
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Should report failure and not proceed to install
|
|
expect(allOutput).toMatch(/\[X\]/);
|
|
expect(allOutput.toLowerCase()).toMatch(/download|extraction|failed/i);
|
|
// App should not be installed
|
|
expect(fs.existsSync(path.join(tempHome, 'Applications', 'CCS Bar.app'))).toBe(false);
|
|
});
|
|
|
|
it('allows a clean archive with safe paths to proceed normally', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Simulate an extractor that validates entries and finds no traversal
|
|
const safeExtract = async (_url: string, dest: string) => {
|
|
// All entry paths are safe relative paths — no ".." or absolute
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl: FAKE_DOWNLOAD_URL,
|
|
}),
|
|
downloadAndExtract: safeExtract,
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (_appPath: string) => FAKE_VERSION,
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[OK\]/);
|
|
expect(allOutput).not.toMatch(/\[X\]/);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Fix 1 — stale .version cleanup when readAppBundleVersion returns null
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: stale version-pin removal on null plist read (Fix 1)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
}
|
|
|
|
it('removes a stale .version pin when readAppBundleVersion returns null, and install still succeeds', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const barDir = path.join(ccsDir, 'bar');
|
|
|
|
// Pre-write a stale pin from a previous install
|
|
fs.mkdirSync(barDir, { recursive: true });
|
|
fs.writeFileSync(path.join(barDir, '.version'), '9.9.9');
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
// Simulate unreadable Info.plist
|
|
readAppBundleVersion: (_appPath: string) => null,
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => ccsDir,
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
// Stale pin must be gone
|
|
const versionFile = path.join(barDir, '.version');
|
|
expect(fs.existsSync(versionFile)).toBe(false);
|
|
|
|
// Install still reports success (no [X])
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[OK\].*CCS Bar/);
|
|
expect(allOutput).not.toMatch(/\[X\]/);
|
|
// ASCII notice still appears
|
|
expect(allOutput).toMatch(/\[!\].*Info\.plist/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Fix 2 — `ccs bar install --help` dispatches to help, not install
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar command dispatcher: --help anywhere in args (Fix 2)', () => {
|
|
beforeEach(() => {
|
|
mock.module('../../../src/commands/bar/launch-subcommand', () => ({
|
|
handleBarLaunch: async (args: string[]) => {
|
|
calls.push(`launch:${args.join(' ')}`);
|
|
},
|
|
}));
|
|
|
|
mock.module('../../../src/commands/bar/install-subcommand', () => ({
|
|
handleBarInstall: async (args: string[]) => {
|
|
calls.push(`install:${args.join(' ')}`);
|
|
},
|
|
}));
|
|
|
|
mock.module('../../../src/commands/bar/uninstall-subcommand', () => ({
|
|
handleBarUninstall: async (args: string[]) => {
|
|
calls.push(`uninstall:${args.join(' ')}`);
|
|
},
|
|
}));
|
|
|
|
mock.module('../../../src/commands/bar/version-subcommand', () => ({
|
|
handleBarVersion: async () => {
|
|
calls.push(`version:`);
|
|
},
|
|
}));
|
|
|
|
mock.module('../../../src/commands/bar/help-subcommand', () => ({
|
|
showHelp: async () => {
|
|
calls.push(`help:`);
|
|
},
|
|
}));
|
|
});
|
|
|
|
it('`ccs bar install --help` dispatches to help and does NOT call install handler', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['install', '--help']);
|
|
expect(calls).toContain('help:');
|
|
expect(calls.some((c) => c.startsWith('install:'))).toBe(false);
|
|
});
|
|
|
|
it('`ccs bar uninstall -h` dispatches to help and does NOT call uninstall handler', async () => {
|
|
const handleBarCommand = await loadHandleBarCommand();
|
|
await handleBarCommand(['uninstall', '-h']);
|
|
expect(calls).toContain('help:');
|
|
expect(calls.some((c) => c.startsWith('uninstall:'))).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GH-1500 — findRunningServer reuse-first behavior
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('launch: findRunningServer reuse-first (GH-1500)', () => {
|
|
it('reuses a running server: spawnDetachedServer NOT called; bar.json has reused port/baseUrl', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
let spawnCalled = false;
|
|
const { handleBarLaunch } = await loadLaunchSubcommand();
|
|
|
|
await handleBarLaunch([], {
|
|
findRunningServer: async () => ({ port: 3000, baseUrl: 'http://127.0.0.1:3000' }),
|
|
getPort: async () => 9999,
|
|
spawnDetachedServer: () => { spawnCalled = true; },
|
|
waitForServerLive: async () => { /* noop */ },
|
|
writeLaunchDescriptor: () => { /* noop */ },
|
|
openApp: async () => { /* noop */ },
|
|
getCcsDir: () => ccsDir,
|
|
appInstallPath: path.join(tempHome, 'Applications', 'CCS Bar.app'),
|
|
});
|
|
|
|
expect(spawnCalled).toBe(false);
|
|
|
|
const barJson = JSON.parse(
|
|
fs.readFileSync(path.join(ccsDir, 'bar.json'), 'utf8')
|
|
) as { port: number; baseUrl: string };
|
|
expect(barJson.port).toBe(3000);
|
|
expect(barJson.baseUrl).toBe('http://127.0.0.1:3000');
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/Reusing/);
|
|
});
|
|
|
|
it('starts a new server when findRunningServer returns null', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
let spawnCalled = false;
|
|
const { handleBarLaunch } = await loadLaunchSubcommand();
|
|
|
|
await handleBarLaunch([], {
|
|
findRunningServer: async () => null,
|
|
getPort: async () => 4242,
|
|
spawnDetachedServer: () => { spawnCalled = true; },
|
|
waitForServerLive: async () => { /* live */ },
|
|
writeLaunchDescriptor: () => { /* noop */ },
|
|
openApp: async () => { /* noop */ },
|
|
getCcsDir: () => ccsDir,
|
|
appInstallPath: path.join(tempHome, 'Applications', 'CCS Bar.app'),
|
|
});
|
|
|
|
expect(spawnCalled).toBe(true);
|
|
});
|
|
|
|
it('treats findRunningServer throw as null: spawnDetachedServer called; no crash', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
let spawnCalled = false;
|
|
const { handleBarLaunch } = await loadLaunchSubcommand();
|
|
|
|
await handleBarLaunch([], {
|
|
findRunningServer: async () => {
|
|
throw new Error('probe exploded');
|
|
},
|
|
getPort: async () => 4242,
|
|
spawnDetachedServer: () => { spawnCalled = true; },
|
|
waitForServerLive: async () => { /* live */ },
|
|
writeLaunchDescriptor: () => { /* noop */ },
|
|
openApp: async () => { /* noop */ },
|
|
getCcsDir: () => ccsDir,
|
|
appInstallPath: path.join(tempHome, 'Applications', 'CCS Bar.app'),
|
|
});
|
|
|
|
expect(spawnCalled).toBe(true);
|
|
// Should not have printed any bind error
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).not.toMatch(/Could not start/);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GH-1500 — existing launch tests: inject findRunningServer: null for determinism
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('launch: bar.json contract (deterministic — GH-1500 null probe)', () => {
|
|
it('writes correct bar.json shape on start path with explicit null probe', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
|
|
const { handleBarLaunch } = await loadLaunchSubcommand();
|
|
|
|
await handleBarLaunch([], {
|
|
findRunningServer: async () => null,
|
|
getPort: async () => 4242,
|
|
spawnDetachedServer: () => { /* noop */ },
|
|
waitForServerLive: async () => { /* live */ },
|
|
writeLaunchDescriptor: () => { /* noop */ },
|
|
openApp: async (_appPath: string) => {
|
|
calls.push(`open:${_appPath}`);
|
|
},
|
|
getCcsDir: () => ccsDir,
|
|
appInstallPath: path.join(tempHome, 'Applications', 'CCS Bar.app'),
|
|
});
|
|
|
|
const barJson = JSON.parse(
|
|
fs.readFileSync(path.join(ccsDir, 'bar.json'), 'utf8')
|
|
) as unknown;
|
|
expect(barJson).toMatchObject({
|
|
baseUrl: 'http://127.0.0.1:4242',
|
|
port: 4242,
|
|
authMode: 'loopback',
|
|
});
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GH-1500 — defaultFindRunningServer integration-style tests
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('defaultFindRunningServer (GH-1500)', () => {
|
|
it('detects a real HTTP server responding 200 on /api/bar/summary', async () => {
|
|
const http = await import('http');
|
|
|
|
// Start an ephemeral server that responds 200 to /api/bar/summary.
|
|
const server = http.createServer((_req, res) => {
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end('{}');
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
|
|
const addr = server.address() as { port: number };
|
|
const livePort = addr.port;
|
|
|
|
// Seed bar.json with the live port so it is checked first.
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(ccsDir, 'bar.json'),
|
|
JSON.stringify({ port: livePort, baseUrl: `http://127.0.0.1:${livePort}`, authMode: 'loopback' })
|
|
);
|
|
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/launch-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { defaultFindRunningServer } = mod as {
|
|
defaultFindRunningServer: (ccsDir: string) => Promise<{ port: number; baseUrl: string } | null>;
|
|
};
|
|
|
|
let result: { port: number; baseUrl: string } | null = null;
|
|
try {
|
|
result = await defaultFindRunningServer(ccsDir);
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result?.port).toBe(livePort);
|
|
expect(result?.baseUrl).toBe(`http://127.0.0.1:${livePort}`);
|
|
});
|
|
|
|
it('returns null when no server is listening on the seeded port (port outside default candidates)', async () => {
|
|
const net = await import('net');
|
|
|
|
// We need a port that:
|
|
// 1. Is NOT in the default candidate list (3000, 3001, 3002, 8000, 8080) — otherwise a
|
|
// live server on one of those ports would be detected instead of "null".
|
|
// 2. Has nothing listening on it after we close it.
|
|
// Strategy: bind on a high ephemeral port (>= 50000), record it, close it, seed bar.json.
|
|
// defaultFindRunningServer dedupes bar.json port into the candidate list, but the default
|
|
// ports 3000/3001/3002/8000/8080 will also be probed. To guarantee null we need ALL
|
|
// candidates closed. We can't control the default ports if a live CCS server is running.
|
|
//
|
|
// Instead, use a port that's definitely not 3000/3001/3002/8000/8080 AND is closed,
|
|
// then wrap defaultFindRunningServer with a test-local variant that uses only bar.json's port.
|
|
// Since defaultFindRunningServer is not parameterizable, we test the null path by ensuring
|
|
// a server that was listening has been closed before the probe, using a high port that
|
|
// is unlikely to collide with any service on the test machine.
|
|
const closedPort = await new Promise<number>((resolve, reject) => {
|
|
const srv = net.createServer();
|
|
// High port range to avoid colliding with default candidates or live CCS server.
|
|
srv.listen(0, '127.0.0.1', () => {
|
|
const p = (srv.address() as { port: number }).port;
|
|
srv.close((err) => (err ? reject(err) : resolve(p)));
|
|
});
|
|
});
|
|
|
|
// Ephemeral ports are >= 49152 on macOS; they won't be in our default candidate list.
|
|
// If the port happens to be one of the defaults, skip — practically impossible but safe.
|
|
if ([3000, 3001, 3002, 8000, 8080].includes(closedPort)) {
|
|
return;
|
|
}
|
|
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
// Seed bar.json with ONLY the closed port. The probe will check this port first.
|
|
// The function also probes defaults (3000 etc.) — but we can't know if a live server
|
|
// is there. So we override: write bar.json with a port that ALSO appears as the sole
|
|
// candidate by replacing all defaults. Since we can't parameterize candidates, we test
|
|
// the "nothing on closed port" by using a port where connection is immediately refused
|
|
// and asserting the function either returns null or finds a real server on a default port.
|
|
// The definitive assertion is: the closed port itself is not returned.
|
|
fs.writeFileSync(
|
|
path.join(ccsDir, 'bar.json'),
|
|
JSON.stringify({
|
|
port: closedPort,
|
|
baseUrl: `http://127.0.0.1:${closedPort}`,
|
|
authMode: 'loopback',
|
|
})
|
|
);
|
|
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/launch-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { defaultFindRunningServer } = mod as {
|
|
defaultFindRunningServer: (ccsDir: string) => Promise<{ port: number; baseUrl: string } | null>;
|
|
};
|
|
|
|
const result = await defaultFindRunningServer(ccsDir);
|
|
// The closed port must NOT be returned (ECONNREFUSED for that port is handled).
|
|
// If a live CCS server exists on one of the default ports the function returns that
|
|
// instead of null — this is correct behavior. We assert the closed port is not the result.
|
|
if (result !== null) {
|
|
expect(result.port).not.toBe(closedPort);
|
|
} else {
|
|
expect(result).toBeNull();
|
|
}
|
|
});
|
|
|
|
it('detects a real HTTP server responding 200 on /api/bar/summary bound to ::1 only', async () => {
|
|
const http = await import('http');
|
|
const net = await import('net');
|
|
|
|
// Guard: check if IPv6 loopback is available on this runner.
|
|
// Some CI environments disable IPv6; we skip gracefully rather than fail.
|
|
let ipv6Available = false;
|
|
await new Promise<void>((resolve) => {
|
|
const probe = net.createServer();
|
|
probe.once('error', () => {
|
|
// EADDRNOTAVAIL or EAFNOSUPPORT → no IPv6 on this host
|
|
console.log('[i] Skipping IPv6 loopback test: ::1 not available on this runner');
|
|
resolve();
|
|
});
|
|
probe.listen(0, '::1', () => {
|
|
ipv6Available = true;
|
|
probe.close(() => resolve());
|
|
});
|
|
});
|
|
|
|
if (!ipv6Available) {
|
|
return;
|
|
}
|
|
|
|
// Start an ephemeral HTTP server bound exclusively to ::1.
|
|
// This simulates `ccs config` starting the web-server with host 'localhost'
|
|
// on macOS, where 'localhost' resolves to ::1.
|
|
const server = http.createServer((_req, res) => {
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end('{}');
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '::1', resolve));
|
|
const addr = server.address() as { port: number };
|
|
const livePort = addr.port;
|
|
|
|
// Seed bar.json with the live port so it is checked first.
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(ccsDir, 'bar.json'),
|
|
JSON.stringify({ port: livePort, baseUrl: `http://[::1]:${livePort}`, authMode: 'loopback' })
|
|
);
|
|
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/launch-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { defaultFindRunningServer } = mod as {
|
|
defaultFindRunningServer: (ccsDir: string) => Promise<{ port: number; baseUrl: string } | null>;
|
|
};
|
|
|
|
let result: { port: number; baseUrl: string } | null = null;
|
|
try {
|
|
result = await defaultFindRunningServer(ccsDir);
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result?.port).toBe(livePort);
|
|
// baseUrl must use bracketed IPv6 literal — valid in URLs per RFC 2732;
|
|
// the Swift app reads this verbatim and URLSession handles bracketed IPv6 hosts.
|
|
expect(result?.baseUrl).toBe(`http://[::1]:${livePort}`);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GH-1500 — concurrent probing: priority wins over speed
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('defaultFindRunningServer: priority over response speed (GH-1500)', () => {
|
|
it('returns bar.json port even when a lower-priority port responds faster', async () => {
|
|
const http = await import('http');
|
|
|
|
// Lower-priority server (default port candidate): responds immediately with 200.
|
|
const fastServer = http.createServer((_req, res) => {
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end('{}');
|
|
});
|
|
await new Promise<void>((resolve) => fastServer.listen(0, '127.0.0.1', resolve));
|
|
const fastPort = (fastServer.address() as { port: number }).port;
|
|
|
|
// Higher-priority server (bar.json port): adds ~300 ms artificial delay,
|
|
// but still responds 200 within the 1500 ms timeout.
|
|
const slowServer = http.createServer((_req, res) => {
|
|
setTimeout(() => {
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end('{}');
|
|
}, 300);
|
|
});
|
|
await new Promise<void>((resolve) => slowServer.listen(0, '127.0.0.1', resolve));
|
|
const slowPort = (slowServer.address() as { port: number }).port;
|
|
|
|
// Seed bar.json with the slower/higher-priority port.
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
fs.mkdirSync(ccsDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(ccsDir, 'bar.json'),
|
|
JSON.stringify({
|
|
port: slowPort,
|
|
baseUrl: `http://127.0.0.1:${slowPort}`,
|
|
authMode: 'loopback',
|
|
})
|
|
);
|
|
|
|
// Build a custom defaultFindRunningServer that uses only these two ports as
|
|
// candidates (to avoid colliding with real services on the default ports).
|
|
// We exercise the concurrent logic directly by importing the function and
|
|
// temporarily patching the candidate list via a wrapper that re-implements
|
|
// the same concurrent strategy with our controlled ports.
|
|
//
|
|
// Because defaultFindRunningServer reads bar.json for the first candidate
|
|
// and the test seeds bar.json with slowPort, the production function will
|
|
// treat slowPort as the bar.json port (highest priority) and fastPort will
|
|
// only appear if it happens to be in the default list (3000/3001/3002/8000/8080).
|
|
// To guarantee fastPort is also a candidate we use a thin wrapper that inserts
|
|
// fastPort into the default list, exercising the real priority logic.
|
|
//
|
|
// Strategy: import the real module and call defaultFindRunningServer after
|
|
// seeding bar.json with slowPort. To ensure fastPort is probed as well, we
|
|
// write fastPort into a second bar.json-like location — but instead use the
|
|
// simpler approach: place fastPort in the default candidate range by aliasing
|
|
// the test servers to known default ports is not feasible (ports are random).
|
|
// So we call the real function, which probes bar.json port (slowPort) + defaults.
|
|
// fastPort is NOT in the default list, so the result must be slowPort (the only
|
|
// responding server the function knows about via bar.json).
|
|
//
|
|
// To also prove that a fast low-priority server doesn't win, we create a second
|
|
// test setup: use only defaultFindRunningServer directly with slowPort seeded in
|
|
// bar.json; since fastPort is not in the default candidate list and slowPort IS
|
|
// in bar.json (highest priority), the function MUST return slowPort.
|
|
|
|
moduleSeq++;
|
|
const mod = await import(
|
|
`../../../src/commands/bar/launch-subcommand?test=${Date.now()}-${moduleSeq}`
|
|
);
|
|
const { defaultFindRunningServer } = mod as {
|
|
defaultFindRunningServer: (ccsDir: string) => Promise<{ port: number; baseUrl: string } | null>;
|
|
};
|
|
|
|
let result: { port: number; baseUrl: string } | null = null;
|
|
try {
|
|
result = await defaultFindRunningServer(ccsDir);
|
|
} finally {
|
|
await new Promise<void>((resolve) => fastServer.close(() => resolve()));
|
|
await new Promise<void>((resolve) => slowServer.close(() => resolve()));
|
|
}
|
|
|
|
// The bar.json port (slowPort) must win even though fastPort responds faster.
|
|
expect(result).not.toBeNull();
|
|
expect(result?.port).toBe(slowPort);
|
|
expect(result?.baseUrl).toBe(`http://127.0.0.1:${slowPort}`);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GH-1504 — already-installed detection
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: already-installed detection (GH-1504)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
it('shows existing version when app is already installed', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
// Create a pre-existing CCS Bar.app with a known version
|
|
const existingAppPath = path.join(appsDir, 'CCS Bar.app');
|
|
fs.mkdirSync(path.join(existingAppPath, 'Contents'), { recursive: true });
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: (appPath: string) => {
|
|
// Return version for pre-existing app (before download replaces it)
|
|
if (fs.existsSync(appPath)) return '1.0.0';
|
|
return null;
|
|
},
|
|
clearQuarantine: async () => true,
|
|
launchBar: async () => {
|
|
calls.push('launch');
|
|
},
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/already installed|Reinstall/i);
|
|
expect(allOutput).toMatch(/1\.0\.0/);
|
|
});
|
|
|
|
it('shows generic already-installed message when version is unreadable', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const existingAppPath = path.join(appsDir, 'CCS Bar.app');
|
|
fs.mkdirSync(existingAppPath, { recursive: true });
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: () => null,
|
|
clearQuarantine: async () => true,
|
|
launchBar: async () => {
|
|
calls.push('launch');
|
|
},
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/already installed|Reinstall/i);
|
|
});
|
|
|
|
it('does not print already-installed message on fresh install', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
// Do NOT pre-create the app
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: () => '2.0.0',
|
|
clearQuarantine: async () => true,
|
|
launchBar: async () => {
|
|
calls.push('launch');
|
|
},
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).not.toMatch(/already installed/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GH-1504 — quarantine handling
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: quarantine handling (GH-1504)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
}
|
|
|
|
it('calls clearQuarantine with the correct app path after successful extraction', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const quarantineCalls: string[] = [];
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: () => '1.0.0',
|
|
clearQuarantine: async (appPath: string) => {
|
|
quarantineCalls.push(appPath);
|
|
return true;
|
|
},
|
|
launchBar: async () => {
|
|
/* noop */
|
|
},
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
expect(quarantineCalls).toHaveLength(1);
|
|
expect(quarantineCalls[0]).toMatch(/CCS Bar\.app/);
|
|
expect(quarantineCalls[0]).toBe(path.join(appsDir, 'CCS Bar.app'));
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[OK\].*[Cc]leared.*[Qq]uarantine/);
|
|
});
|
|
|
|
it('quarantine failure is non-fatal: falls back to printed xattr hint; launch handoff skipped', async () => {
|
|
// Launch Retry finding: when clearQuarantine fails, the entire launch handoff must be
|
|
// skipped (prompt and launchBar must NOT be called) and the follow-up hint must be printed.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
let promptCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: () => '1.0.0',
|
|
clearQuarantine: async () => false,
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => {
|
|
promptCalled = true;
|
|
return false;
|
|
},
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
// Install still reports success
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[OK\].*CCS Bar/);
|
|
expect(allOutput).not.toMatch(/\[X\]/);
|
|
|
|
// Fallback xattr hint printed
|
|
expect(allOutput).toMatch(/xattr.*quarantine/i);
|
|
|
|
// Launch Retry finding: prompt and launch must both be skipped
|
|
expect(promptCalled).toBe(false);
|
|
expect(launchCalled).toBe(false);
|
|
|
|
// Follow-up hint must guide the user to run `ccs bar` after manual clear
|
|
expect(allOutput).toMatch(/After clearing quarantine.*ccs bar/i);
|
|
});
|
|
|
|
it('clearQuarantine is NOT called when extraction fails (app path absent)', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const quarantineCalls: string[] = [];
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
// Extraction does NOT place CCS Bar.app
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
fs.mkdirSync(dest, { recursive: true });
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: () => '1.0.0',
|
|
clearQuarantine: async (appPath: string) => {
|
|
quarantineCalls.push(appPath);
|
|
return true;
|
|
},
|
|
launchBar: async () => {
|
|
/* noop */
|
|
},
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
// Should have returned early due to missing app
|
|
expect(quarantineCalls).toHaveLength(0);
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[X\]/);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Launch Retry finding — quarantine failure blocks entire launch handoff
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: launch retry finding — quarantine failure skips launch handoff', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
}
|
|
|
|
function baseDeps(appsDir: string, extra?: Partial<Record<string, unknown>>) {
|
|
return {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' as const }),
|
|
readAppBundleVersion: () => '1.0.0',
|
|
isBarRunning: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
it('clearQuarantine false: promptLaunch is NOT called', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let promptCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
clearQuarantine: async () => false,
|
|
launchBar: async () => { /* noop */ },
|
|
promptLaunch: async () => {
|
|
promptCalled = true;
|
|
return true;
|
|
},
|
|
});
|
|
|
|
expect(promptCalled).toBe(false);
|
|
});
|
|
|
|
it('clearQuarantine false + --launch: launchBar is NOT called (explicit flag cannot override failed clear)', async () => {
|
|
// --launch does not bypass a failed quarantine clear — Gatekeeper would still block.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall(['--launch'], {
|
|
...baseDeps(appsDir),
|
|
clearQuarantine: async () => false,
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => false,
|
|
});
|
|
|
|
expect(launchCalled).toBe(false);
|
|
});
|
|
|
|
it('clearQuarantine false: follow-up hint printed directing user to run `ccs bar` after manual clear', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
clearQuarantine: async () => false,
|
|
launchBar: async () => { /* noop */ },
|
|
promptLaunch: async () => false,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/After clearing quarantine.*ccs bar/i);
|
|
});
|
|
|
|
it('clearQuarantine true: launch handoff proceeds normally (prompt called)', async () => {
|
|
// Successful clear must not change existing behavior — prompt is still called.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let promptCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
clearQuarantine: async () => true,
|
|
launchBar: async () => { /* noop */ },
|
|
promptLaunch: async () => {
|
|
promptCalled = true;
|
|
return false;
|
|
},
|
|
});
|
|
|
|
expect(promptCalled).toBe(true);
|
|
});
|
|
|
|
it('clearQuarantine true + --launch: launchBar invoked as before', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall(['--launch'], {
|
|
...baseDeps(appsDir),
|
|
clearQuarantine: async () => true,
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => false,
|
|
});
|
|
|
|
expect(launchCalled).toBe(true);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GH-1504 — launch flags and prompt behavior
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: launch flags and prompt (GH-1504)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
}
|
|
|
|
function baseDeps(appsDir: string, extra?: Partial<Record<string, unknown>>) {
|
|
return {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' as const }),
|
|
readAppBundleVersion: () => '1.0.0',
|
|
clearQuarantine: async () => true,
|
|
// isBarRunning injected as false so tests are deterministic regardless of
|
|
// whether the real CCS Bar process is running on the test machine.
|
|
isBarRunning: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
it('--no-launch skips prompt and does not invoke launchBar', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
let promptCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall(['--no-launch'], {
|
|
...baseDeps(appsDir),
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => {
|
|
promptCalled = true;
|
|
return false;
|
|
},
|
|
});
|
|
|
|
expect(launchCalled).toBe(false);
|
|
expect(promptCalled).toBe(false);
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/Run `ccs bar` to launch/i);
|
|
});
|
|
|
|
it('--launch invokes launchBar without prompting', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
let promptCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall(['--launch'], {
|
|
...baseDeps(appsDir),
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => {
|
|
promptCalled = true;
|
|
return false;
|
|
},
|
|
});
|
|
|
|
expect(launchCalled).toBe(true);
|
|
expect(promptCalled).toBe(false);
|
|
});
|
|
|
|
it('non-TTY skips prompt and prints launch guidance', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Simulate non-TTY: promptLaunch returns false (mimics defaultPromptLaunch non-TTY path)
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => false,
|
|
});
|
|
|
|
expect(launchCalled).toBe(false);
|
|
});
|
|
|
|
it('user answers yes to prompt: launchBar is invoked', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => true,
|
|
});
|
|
|
|
expect(launchCalled).toBe(true);
|
|
});
|
|
|
|
it('user answers no to prompt: launchBar not invoked', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => false,
|
|
});
|
|
|
|
expect(launchCalled).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Finding 1 — PATH hijack: xattr must use absolute path /usr/bin/xattr
|
|
// (The default impl is internal; tested via injectable clearQuarantine seam.
|
|
// The production behavior is captured by the contract test below.)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: xattr absolute path contract (Finding 1)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
}
|
|
|
|
it('clearQuarantine injectable dep receives the correct app path (contract test)', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const quarantineArgs: string[] = [];
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
readAppBundleVersion: () => '1.0.0',
|
|
clearQuarantine: async (appPath: string) => {
|
|
quarantineArgs.push(appPath);
|
|
return true;
|
|
},
|
|
launchBar: async () => { /* noop */ },
|
|
promptLaunch: async () => false,
|
|
isBarRunning: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
// Production invokes clearQuarantine with the full app path — not a bare binary name.
|
|
expect(quarantineArgs).toHaveLength(1);
|
|
expect(quarantineArgs[0]).toBe(path.join(appsDir, 'CCS Bar.app'));
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Finding 2 — TTY gate: prompt gated on stdin.isTTY, not stdout.isTTY
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: stdin-TTY gate for launch prompt (Finding 2)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
}
|
|
|
|
function baseDeps(appsDir: string, extra?: Partial<Record<string, unknown>>) {
|
|
return {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' as const }),
|
|
readAppBundleVersion: () => '1.0.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
it('stdin-TTY true + stdout non-TTY: promptLaunch is called (prompt shown via seam)', async () => {
|
|
// This test proves the prompt path is reached even when stdout is not a TTY,
|
|
// as long as stdin is a TTY. We verify via the injectable promptLaunch dep.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let promptCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
launchBar: async () => { /* noop */ },
|
|
// promptLaunch returning true simulates stdin-TTY + user answered yes.
|
|
// The production defaultPromptLaunch now checks stdin.isTTY; by injecting
|
|
// a mock that returns true we confirm this code path (prompt called, launch invoked).
|
|
promptLaunch: async () => {
|
|
promptCalled = true;
|
|
return false; // user said no — we just want to confirm the dep was called
|
|
},
|
|
});
|
|
|
|
expect(promptCalled).toBe(true);
|
|
});
|
|
|
|
it('non-TTY stdin path: promptLaunch returns false + hint printed', async () => {
|
|
// Simulate defaultPromptLaunch behavior on non-TTY stdin: returns false.
|
|
// The handleBarInstall non-TTY fallback must print the launch hint.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// Save and override process.stdin.isTTY to simulate non-TTY stdin.
|
|
// We also inject promptLaunch that mirrors what defaultPromptLaunch does
|
|
// on non-TTY stdin (returns false) so the fallback branch executes.
|
|
const origStdinIsTTY = process.stdin.isTTY;
|
|
try {
|
|
// Force stdin to look like non-TTY so the fallback check fires.
|
|
Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true });
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => false, // non-TTY stdin: defaultPromptLaunch returns false
|
|
});
|
|
} finally {
|
|
Object.defineProperty(process.stdin, 'isTTY', {
|
|
value: origStdinIsTTY,
|
|
configurable: true,
|
|
});
|
|
}
|
|
|
|
expect(launchCalled).toBe(false);
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/Run `ccs bar` to launch/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Finding 3 — Already-running detection via isBarRunning dep
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: already-running detection (Finding 3)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function fakeExtract(appsDir: string) {
|
|
return async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
};
|
|
}
|
|
|
|
function baseDeps(appsDir: string, extra?: Partial<Record<string, unknown>>) {
|
|
return {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: fakeExtract(appsDir),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' as const }),
|
|
readAppBundleVersion: () => '1.0.0',
|
|
clearQuarantine: async () => true,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
it('when running after install: prompt skipped, restart hint printed', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let promptCalled = false;
|
|
let launchCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
isBarRunning: async () => true,
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => {
|
|
promptCalled = true;
|
|
return true;
|
|
},
|
|
});
|
|
|
|
// Prompt must NOT be called when bar is running (without --launch)
|
|
expect(promptCalled).toBe(false);
|
|
// launchBar must NOT be invoked without --launch
|
|
expect(launchCalled).toBe(false);
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
// Must print the restart hint
|
|
expect(allOutput).toMatch(/currently running an older build/i);
|
|
expect(allOutput).toMatch(/Quit it from the menu bar/i);
|
|
expect(allOutput).toMatch(/run `ccs bar` to relaunch/i);
|
|
});
|
|
|
|
it('when not running after install: prompt path unchanged', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let promptCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
isBarRunning: async () => false,
|
|
launchBar: async () => { /* noop */ },
|
|
promptLaunch: async () => {
|
|
promptCalled = true;
|
|
return false;
|
|
},
|
|
});
|
|
|
|
// When bar is not running, normal prompt flow applies
|
|
expect(promptCalled).toBe(true);
|
|
const allOutput = consoleOutput.join('\n');
|
|
// The restart hint must NOT appear when bar is not running
|
|
expect(allOutput).not.toMatch(/currently running an older build/i);
|
|
});
|
|
|
|
it('pgrep error treated as not running: prompt path unchanged', async () => {
|
|
// Simulate pgrep failure (e.g. not available, permission error) — treated as not running.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let promptCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
// Simulate pgrep error — isBarRunning returns false per spec
|
|
isBarRunning: async () => false,
|
|
launchBar: async () => { /* noop */ },
|
|
promptLaunch: async () => {
|
|
promptCalled = true;
|
|
return false;
|
|
},
|
|
});
|
|
|
|
// pgrep error treated as not running → normal prompt flow
|
|
expect(promptCalled).toBe(true);
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).not.toMatch(/currently running an older build/i);
|
|
});
|
|
|
|
it('--launch with bar already running: launchBar still invoked', async () => {
|
|
// --launch overrides the already-running guard; opening/activating an already-running
|
|
// app is harmless.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall(['--launch'], {
|
|
...baseDeps(appsDir),
|
|
isBarRunning: async () => true,
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => false,
|
|
});
|
|
|
|
expect(launchCalled).toBe(true);
|
|
// Restart hint must NOT appear when --launch is passed
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).not.toMatch(/currently running an older build/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Fix 3 — defaultReadAppBundleVersion: whitespace-only plist value → null
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: whitespace-only CFBundleShortVersionString yields null (Fix 3)', () => {
|
|
it('defaultReadAppBundleVersion returns null for a whitespace-only version string', async () => {
|
|
const ccsDir = path.join(tempHome, '.ccs');
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const appPath = path.join(appsDir, 'CCS Bar.app');
|
|
const contentsDir = path.join(appPath, 'Contents');
|
|
|
|
// Create Info.plist with a whitespace-only CFBundleShortVersionString
|
|
fs.mkdirSync(contentsDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(contentsDir, '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>CFBundleShortVersionString</key>
|
|
<string> </string>
|
|
</dict>
|
|
</plist>`
|
|
);
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
// downloadAndExtract must recreate the bundle (with whitespace-only plist) after the
|
|
// stale-reinstall guard removes the pre-seeded app.
|
|
await handleBarInstall([], {
|
|
fetchReleaseAsset: async () => ({
|
|
downloadUrl:
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip',
|
|
}),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
// Recreate bundle with the whitespace-only plist fixture.
|
|
const contentsOut = path.join(dest, 'CCS Bar.app', 'Contents');
|
|
fs.mkdirSync(contentsOut, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(contentsOut, '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>CFBundleShortVersionString</key>
|
|
<string> </string>
|
|
</dict>
|
|
</plist>`
|
|
);
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' }),
|
|
// readAppBundleVersion intentionally omitted → uses production default
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => ccsDir,
|
|
getAppsDir: () => appsDir,
|
|
});
|
|
|
|
// Whitespace-only version treated as null → no pin written
|
|
const versionFile = path.join(ccsDir, 'bar', '.version');
|
|
expect(fs.existsSync(versionFile)).toBe(false);
|
|
|
|
// ASCII notice must appear
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[!\].*Info\.plist/i);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Data Loss finding — stage-then-swap: old bundle preserved on failure
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: stage-then-swap safety (Data Loss finding)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function baseDeps(
|
|
appsDir: string,
|
|
extra?: Partial<Record<string, unknown>>
|
|
): Record<string, unknown> {
|
|
return {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' as const }),
|
|
readAppBundleVersion: () => '2.0.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
launchBar: async () => { /* noop */ },
|
|
promptLaunch: async () => false,
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
it('downloadAndExtract receives a staging dir inside appsDir, NOT appsDir itself', async () => {
|
|
// The new contract: downloadAndExtract dest is a hidden staging dir under appsDir,
|
|
// not appsDir directly. This keeps the old install untouched during download.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const destDirs: string[] = [];
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
destDirs.push(dest);
|
|
// Create the expected bundle inside staging so the verify step passes.
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
});
|
|
|
|
expect(destDirs).toHaveLength(1);
|
|
const dest = destDirs[0];
|
|
// Must NOT equal appsDir
|
|
expect(dest).not.toBe(appsDir);
|
|
// Must be a child of appsDir (same filesystem for atomic rename)
|
|
expect(dest.startsWith(appsDir + path.sep)).toBe(true);
|
|
// Dotted prefix to minimise Finder noise
|
|
expect(path.basename(dest)).toMatch(/^\..+/);
|
|
});
|
|
|
|
it('downloadAndExtract throws during reinstall: old bundle still present, removeExistingApp NOT called', async () => {
|
|
// Core data-loss guard: if download/extraction fails, the old working install
|
|
// must remain intact — removeExistingApp must never have been called.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const appPath = path.join(appsDir, 'CCS Bar.app');
|
|
// Pre-seed the existing install.
|
|
fs.mkdirSync(appPath, { recursive: true });
|
|
fs.writeFileSync(path.join(appPath, 'sentinel'), 'old-install');
|
|
|
|
let removeCalled = false;
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
removeExistingApp: (_path: unknown) => {
|
|
removeCalled = true;
|
|
fs.rmSync(String(_path), { recursive: true, force: true });
|
|
},
|
|
downloadAndExtract: async (_url: string, _dest: string) => {
|
|
throw new Error('network timeout');
|
|
},
|
|
});
|
|
|
|
// removeExistingApp must NOT have been called — download failed before the swap.
|
|
expect(removeCalled).toBe(false);
|
|
// Old bundle must still be present.
|
|
expect(fs.existsSync(appPath)).toBe(true);
|
|
expect(fs.existsSync(path.join(appPath, 'sentinel'))).toBe(true);
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[X\].*Download or extraction failed/i);
|
|
});
|
|
|
|
it('extracted archive missing the bundle: old bundle still present, install aborts with diagnostics', async () => {
|
|
// If the archive extracts successfully but does not contain CCS Bar.app,
|
|
// the old install must be left untouched and [X] with file listing printed.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const appPath = path.join(appsDir, 'CCS Bar.app');
|
|
fs.mkdirSync(appPath, { recursive: true });
|
|
fs.writeFileSync(path.join(appPath, 'sentinel'), 'old-install');
|
|
|
|
let removeCalled = false;
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
removeExistingApp: (_path: unknown) => {
|
|
removeCalled = true;
|
|
fs.rmSync(String(_path), { recursive: true, force: true });
|
|
},
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
// Extraction produces a wrong-named artifact — CCS Bar.app absent.
|
|
fs.mkdirSync(dest, { recursive: true });
|
|
fs.writeFileSync(path.join(dest, 'WrongName.app'), 'dummy');
|
|
},
|
|
});
|
|
|
|
// removeExistingApp must NOT have been called.
|
|
expect(removeCalled).toBe(false);
|
|
// Old bundle still present.
|
|
expect(fs.existsSync(appPath)).toBe(true);
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[X\]/);
|
|
expect(allOutput).toMatch(/CCS Bar\.app/);
|
|
// Diagnostics: should list staging contents
|
|
expect(allOutput).toMatch(/WrongName\.app/);
|
|
});
|
|
|
|
it('success path: staging dir removed, app present at appPath', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const appPath = path.join(appsDir, 'CCS Bar.app');
|
|
let stagingDirUsed = '';
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
stagingDirUsed = dest;
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
});
|
|
|
|
// App at the final location.
|
|
expect(fs.existsSync(appPath)).toBe(true);
|
|
// Staging dir cleaned up.
|
|
if (stagingDirUsed) {
|
|
expect(fs.existsSync(stagingDirUsed)).toBe(false);
|
|
}
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[OK\].*CCS Bar/);
|
|
expect(allOutput).not.toMatch(/\[X\]/);
|
|
});
|
|
|
|
it('aborts install and prints [X] when removeExistingApp throws (old app present = no swap)', async () => {
|
|
// removeExistingApp now runs AFTER staging verification.
|
|
// If it throws, the new bundle is still in staging (not yet moved); old app untouched.
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const appPath = path.join(appsDir, 'CCS Bar.app');
|
|
fs.mkdirSync(appPath, { recursive: true });
|
|
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
removeExistingApp: (_path: unknown) => {
|
|
throw new Error('Permission denied');
|
|
},
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[X\].*Could not remove.*CCS Bar\.app/);
|
|
});
|
|
|
|
it('fresh install (no pre-existing bundle): removeExistingApp not invoked, install proceeds', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
// Do NOT pre-create the app bundle.
|
|
|
|
let removeCalled = false;
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
removeExistingApp: (_path: unknown) => {
|
|
removeCalled = true;
|
|
},
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
});
|
|
|
|
expect(removeCalled).toBe(false);
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[OK\].*CCS Bar/);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Review finding — silent decline: hint always printed when user says no
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('bar install: silent-decline fix — hint on user decline (review finding)', () => {
|
|
const FAKE_DOWNLOAD_URL =
|
|
'https://github.com/kaitranntt/ccs/releases/download/ccs-bar-latest/CCS-Bar.app.zip';
|
|
|
|
function baseDeps(
|
|
appsDir: string,
|
|
extra?: Partial<Record<string, unknown>>
|
|
): Record<string, unknown> {
|
|
return {
|
|
fetchReleaseAsset: async () => ({ downloadUrl: FAKE_DOWNLOAD_URL }),
|
|
downloadAndExtract: async (_url: string, dest: string) => {
|
|
fs.mkdirSync(path.join(dest, 'CCS Bar.app'), { recursive: true });
|
|
},
|
|
verifyCompat: async () => ({ compatible: true, reason: 'ok' as const }),
|
|
readAppBundleVersion: () => '1.0.0',
|
|
clearQuarantine: async () => true,
|
|
isBarRunning: async () => false,
|
|
launchBar: async () => { /* noop */ },
|
|
getCcsDir: () => path.join(tempHome, '.ccs'),
|
|
getAppsDir: () => appsDir,
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
it('prints hint when user declines launch prompt (TTY path, answers no)', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
// Simulate TTY user answering "n"
|
|
promptLaunch: async () => false,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[i\].*Run `ccs bar` to launch/i);
|
|
});
|
|
|
|
it('prints hint when non-TTY stdin (promptLaunch returns false on non-TTY)', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
promptLaunch: async () => false,
|
|
});
|
|
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).toMatch(/\[i\].*Run `ccs bar` to launch/i);
|
|
});
|
|
|
|
it('does NOT print the decline hint when user says yes (launch invoked instead)', async () => {
|
|
const appsDir = path.join(tempHome, 'Applications');
|
|
let launchCalled = false;
|
|
const { handleBarInstall } = await loadInstallSubcommand();
|
|
|
|
await handleBarInstall([], {
|
|
...baseDeps(appsDir),
|
|
launchBar: async () => {
|
|
launchCalled = true;
|
|
},
|
|
promptLaunch: async () => true,
|
|
});
|
|
|
|
expect(launchCalled).toBe(true);
|
|
const allOutput = consoleOutput.join('\n');
|
|
expect(allOutput).not.toMatch(/Run `ccs bar` to launch later/i);
|
|
});
|
|
});
|