@pi-chamber/web 1.0.5-rc.1 → 1.0.5-rc.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/bin/lib/DOCUMENTATION.md +1 -1
- package/bin/lib/commands-status.js +3 -2
- package/bin/lib/commands-status.test.js +62 -0
- package/dist/assets/{DiagramView-D-OSWTbO.js → DiagramView-DxLAcmg-.js} +1 -1
- package/dist/assets/{DiffView-BKT-MIH4.js → DiffView-BzVBoNCp.js} +1 -1
- package/dist/assets/{FileSaveConflictDialog-DBkVFssC.js → FileSaveConflictDialog-2KqGdUdB.js} +1 -1
- package/dist/assets/{FilesView-B7GIuRlh.js → FilesView-3spQTRpf.js} +1 -1
- package/dist/assets/{GitHubDetailScaffold-C9rCZMUT.js → GitHubDetailScaffold-C2d4WqKe.js} +1 -1
- package/dist/assets/{GitHubLinkPicker-Bm09hvhJ.js → GitHubLinkPicker-BDwZtk0x.js} +1 -1
- package/dist/assets/{GitHubListPrimitives-DlhAlxI6.js → GitHubListPrimitives-Dor_K85Y.js} +1 -1
- package/dist/assets/{GitView-BgqdMb0m.js → GitView-CSAJagWK.js} +3 -3
- package/dist/assets/{IssuesSurface-BZXAvt49.js → IssuesSurface-euZzv2L9.js} +1 -1
- package/dist/assets/{JsonTreeView-BKgCQjh_.js → JsonTreeView-Drmn7tIN.js} +1 -1
- package/dist/assets/{MarkdownRendererImpl-BdcyMPw-.js → MarkdownRendererImpl-Bq0p5v9N.js} +1 -1
- package/dist/assets/{PatchDiff-2MmWXcGe.js → PatchDiff-BegAimf3.js} +1 -1
- package/dist/assets/{PierreDiffViewer-D1F2WvD0.js → PierreDiffViewer-DgU2Zcmr.js} +1 -1
- package/dist/assets/{PullRequestsSurface-CN2z3DFv.js → PullRequestsSurface-CnGgmkuf.js} +2 -2
- package/dist/assets/{SessionSwitcherContent-CCljxAZb.js → SessionSwitcherContent-Cq5LIBuG.js} +1 -1
- package/dist/assets/{SessionSwitcherDropdown-DtNt3qw4.js → SessionSwitcherDropdown-Dpob2_y5.js} +2 -2
- package/dist/assets/{SessionUnreadDot-B9bHMy5q.js → SessionUnreadDot-BPKnpGAh.js} +1 -1
- package/dist/assets/{SettingsView-DaZVCInW.js → SettingsView-DcOJRyym.js} +4 -4
- package/dist/assets/{SettingsWindow-C-ydfopH.js → SettingsWindow-C2RB0AjV.js} +1 -1
- package/dist/assets/{ToolOutputDialog-DJUAx_Oj.js → ToolOutputDialog-DmzNX2QX.js} +1 -1
- package/dist/assets/{ToolPartDiffPreview-DFyuJM4c.js → ToolPartDiffPreview-CO5Gg17_.js} +1 -1
- package/dist/assets/{VirtualizedFileDiff-BS-af6rn.js → VirtualizedFileDiff-CJ1m8JE-.js} +1 -1
- package/dist/assets/{computeVirtualFileMetrics-BI6wORhM.js → computeVirtualFileMetrics-8mC_o5zA.js} +1 -1
- package/dist/assets/{contextFileOpenGuard-DUMSGR4M.js → contextFileOpenGuard-CRboGmXF.js} +1 -1
- package/dist/assets/{gitStatusPredicates-FdKYDZe3.js → gitStatusPredicates-BqV-kOGY.js} +1 -1
- package/dist/assets/{githubLink-B3-BaGpb.js → githubLink-DSgdECMr.js} +1 -1
- package/dist/assets/{index-Df-vmvzu.js → index-B3qmI8VW.js} +1 -1
- package/dist/assets/{main-61_cd7S7.js → main-Bn93XwxQ.js} +2 -2
- package/dist/assets/{main-q43jqZ2I.js → main-HPNu-7DG.js} +4 -4
- package/dist/assets/{markdownCore-CqHYlXi_.js → markdownCore-Csm6UEBe.js} +1 -1
- package/dist/assets/{miniChat-vOuWN5pV.js → miniChat-C3W5IvM4.js} +2 -2
- package/dist/assets/{mobile-mrXWV5ky.js → mobile-COEEitAQ.js} +2 -2
- package/dist/assets/{pi-session-focus-preference-BEufpwC6.js → pi-session-focus-preference-DQjF7Nh1.js} +1 -1
- package/dist/assets/{renderDiffWithHighlighter-BD9CAhZU.js → renderDiffWithHighlighter-BBwvKSDe.js} +1 -1
- package/dist/assets/{renderElectronMiniChatApp-QQFXkY5Y.js → renderElectronMiniChatApp-7vIiCPiK.js} +2 -2
- package/dist/assets/{renderFileWithHighlighter-KiEWMtzI.js → renderFileWithHighlighter-VOwWxIE1.js} +1 -1
- package/dist/assets/{renderMobileApp-DIZYvrhi.js → renderMobileApp-BQDG02OP.js} +3 -3
- package/dist/assets/{runtimeEndpointReset-BA2uP2rj.js → runtimeEndpointReset-CzwDZ_EP.js} +4 -4
- package/dist/assets/{useAppFontEffects-Bfw_d5eB.js → useAppFontEffects-BQ1JUauS.js} +6 -6
- package/dist/assets/{useFilesViewSearch-Budwejnx.js → useFilesViewSearch-BYG2TZWz.js} +1 -1
- package/dist/assets/{useGitHubRemoteSearch-gUdylYy3.js → useGitHubRemoteSearch-Bo1LF-x_.js} +1 -1
- package/dist/assets/{useSwitcherItems-yHSMduoo.js → useSwitcherItems-q0ZavMJb.js} +1 -1
- package/dist/assets/{web-components-CeHLxvED.js → web-components-CJ0xIy7r.js} +1 -1
- package/dist/index.html +1 -1
- package/dist/mini-chat.html +1 -1
- package/dist/mobile.html +1 -1
- package/package.json +1 -1
- package/server/index.js +4 -1
- package/server/lib/tailscale/DOCUMENTATION.md +56 -6
- package/server/lib/tailscale/nc-probe.js +220 -0
- package/server/lib/tailscale/public-dns.js +72 -0
- package/server/lib/tailscale/service.js +183 -7
- package/server/lib/tailscale/tailscale.test.js +537 -1
|
@@ -17,6 +17,7 @@ import {
|
|
|
17
17
|
validateTailscaleConfig,
|
|
18
18
|
} from './tailscale.js';
|
|
19
19
|
import { createTailscaleService } from './service.js';
|
|
20
|
+
import { createTailscaleNcHealthFetch } from './nc-probe.js';
|
|
20
21
|
|
|
21
22
|
describe('tailscale status parsing', () => {
|
|
22
23
|
it('strips the trailing dot from DNSName and reports login state', () => {
|
|
@@ -205,7 +206,7 @@ const TEST_SERVER_ID = 'test-server-id';
|
|
|
205
206
|
const matchingFetchImpl = async () => ({ ok: true, status: 200, json: async () => ({ serverId: TEST_SERVER_ID }) });
|
|
206
207
|
|
|
207
208
|
/** In-memory fs + scripted command runner for lifecycle tests. */
|
|
208
|
-
const createHarness = ({ handlers, port = 3000, uiPassword = 'secret' } = {}) => {
|
|
209
|
+
const createHarness = ({ handlers, port = 3000, uiPassword = 'secret', resolvePublicDns } = {}) => {
|
|
209
210
|
const files = new Map();
|
|
210
211
|
const calls = [];
|
|
211
212
|
const fsPromises = {
|
|
@@ -253,6 +254,12 @@ const createHarness = ({ handlers, port = 3000, uiPassword = 'secret' } = {}) =>
|
|
|
253
254
|
fsPromises,
|
|
254
255
|
existsSync: () => false,
|
|
255
256
|
fetchImpl: async () => ({ ok: false, status: 404, json: async () => null }),
|
|
257
|
+
// Fail closed by default: no existing test exercises the tailnet path,
|
|
258
|
+
// and the real `tailscale nc` implementation must never spawn here.
|
|
259
|
+
tailnetHealthFetch: async () => ({ ok: false, status: null, body: null, error: 'disabled-in-test' }),
|
|
260
|
+
// Never touch real DNS in tests: default to not-found (keeps existing
|
|
261
|
+
// tests unchanged); public-DNS tests inject their own sequence.
|
|
262
|
+
resolvePublicDns: resolvePublicDns || (async () => 'not-found'),
|
|
256
263
|
logWarn: () => {},
|
|
257
264
|
});
|
|
258
265
|
return { service, calls, files, fsPromises };
|
|
@@ -1151,6 +1158,7 @@ describe('tailscale crash-restart repoint (record-owned mapping on a new port)',
|
|
|
1151
1158
|
fsPromises,
|
|
1152
1159
|
getServerId: async () => TEST_SERVER_ID,
|
|
1153
1160
|
fetchImpl: matchingFetchImpl,
|
|
1161
|
+
resolvePublicDns: async () => 'not-found',
|
|
1154
1162
|
logWarn: () => {},
|
|
1155
1163
|
});
|
|
1156
1164
|
await service.loadConfig();
|
|
@@ -1859,3 +1867,531 @@ describe('tailscale reconcile serialization (Off/Private overlap)', () => {
|
|
|
1859
1867
|
}
|
|
1860
1868
|
});
|
|
1861
1869
|
});
|
|
1870
|
+
|
|
1871
|
+
describe('tailscale tailnet-path probe fallback (nc)', () => {
|
|
1872
|
+
const memFsFor = () => {
|
|
1873
|
+
const memFs = new Map();
|
|
1874
|
+
return {
|
|
1875
|
+
memFs,
|
|
1876
|
+
fsPromises: {
|
|
1877
|
+
readFile: async (p) => {
|
|
1878
|
+
if (!memFs.has(p)) { const e = new Error('x'); e.code = 'ENOENT'; throw e; }
|
|
1879
|
+
return memFs.get(p);
|
|
1880
|
+
},
|
|
1881
|
+
writeFile: async (p, c) => { memFs.set(p, String(c)); },
|
|
1882
|
+
mkdir: async () => {},
|
|
1883
|
+
rename: async (a, b) => { memFs.set(b, memFs.get(a)); memFs.delete(a); },
|
|
1884
|
+
unlink: async (p) => { memFs.delete(p); },
|
|
1885
|
+
},
|
|
1886
|
+
};
|
|
1887
|
+
};
|
|
1888
|
+
const createProbeService = ({ fetchImpl, tailnetHealthFetch }) => {
|
|
1889
|
+
const { fsPromises } = memFsFor();
|
|
1890
|
+
const fallbackCalls = [];
|
|
1891
|
+
const service = createTailscaleService({
|
|
1892
|
+
existsSync: () => false,
|
|
1893
|
+
dataDir: '/data',
|
|
1894
|
+
getPort: () => 3000,
|
|
1895
|
+
isUiAuthEnabled: () => true,
|
|
1896
|
+
isUnsafeUnauthenticatedLanAllowed: () => false,
|
|
1897
|
+
runner: {
|
|
1898
|
+
runTailscale: async (args) => {
|
|
1899
|
+
if (args.includes('serve') && args.includes('status')) {
|
|
1900
|
+
return { ok: true, code: 0, stdout: JSON.stringify({ Web: {} }), stderr: '', spawnError: null, timedOut: false };
|
|
1901
|
+
}
|
|
1902
|
+
return { ok: true, code: 0, stdout: STATUS_JSON, stderr: '', spawnError: null, timedOut: false };
|
|
1903
|
+
},
|
|
1904
|
+
},
|
|
1905
|
+
fsPromises,
|
|
1906
|
+
getServerId: async () => TEST_SERVER_ID,
|
|
1907
|
+
fetchImpl,
|
|
1908
|
+
tailnetHealthFetch: async (args) => {
|
|
1909
|
+
fallbackCalls.push(args);
|
|
1910
|
+
return tailnetHealthFetch(args);
|
|
1911
|
+
},
|
|
1912
|
+
resolvePublicDns: async () => 'not-found',
|
|
1913
|
+
logWarn: () => {},
|
|
1914
|
+
});
|
|
1915
|
+
return { service, fallbackCalls };
|
|
1916
|
+
};
|
|
1917
|
+
const directDnsFailure = async () => {
|
|
1918
|
+
throw new Error('getaddrinfo ENOTFOUND mymachine.tailabc.ts.net');
|
|
1919
|
+
};
|
|
1920
|
+
|
|
1921
|
+
it('goes active when the direct fetch throws but the tailnet path answers', async () => {
|
|
1922
|
+
const { service, fallbackCalls } = createProbeService({
|
|
1923
|
+
fetchImpl: directDnsFailure,
|
|
1924
|
+
tailnetHealthFetch: async () => ({ ok: true, status: 200, body: { serverId: TEST_SERVER_ID } }),
|
|
1925
|
+
});
|
|
1926
|
+
await service.loadConfig();
|
|
1927
|
+
const result = await service.setConfig({ enabled: true, mode: 'private', httpsPort: 443 });
|
|
1928
|
+
expect(result.state).toBe('active');
|
|
1929
|
+
expect(result.url).toBe('https://mymachine.tailabc.ts.net');
|
|
1930
|
+
expect(fallbackCalls).toHaveLength(1);
|
|
1931
|
+
expect(fallbackCalls[0]).toMatchObject({ host: 'mymachine.tailabc.ts.net', port: 443 });
|
|
1932
|
+
service.dispose();
|
|
1933
|
+
});
|
|
1934
|
+
|
|
1935
|
+
it('stays starting when the tailnet path reports a different server', async () => {
|
|
1936
|
+
const { service, fallbackCalls } = createProbeService({
|
|
1937
|
+
fetchImpl: directDnsFailure,
|
|
1938
|
+
tailnetHealthFetch: async () => ({ ok: true, status: 200, body: { serverId: 'some-other-server' } }),
|
|
1939
|
+
});
|
|
1940
|
+
await service.loadConfig();
|
|
1941
|
+
const result = await service.setConfig({ enabled: true, mode: 'private', httpsPort: 443 });
|
|
1942
|
+
expect(result.state).toBe('starting');
|
|
1943
|
+
expect(result.url).toBeNull();
|
|
1944
|
+
expect(fallbackCalls).toHaveLength(1);
|
|
1945
|
+
service.dispose();
|
|
1946
|
+
});
|
|
1947
|
+
|
|
1948
|
+
it('never uses the tailnet path when the direct path answers', async () => {
|
|
1949
|
+
// Non-OK direct response.
|
|
1950
|
+
const nonOk = createProbeService({
|
|
1951
|
+
fetchImpl: async () => ({ ok: false, status: 404, json: async () => null }),
|
|
1952
|
+
tailnetHealthFetch: async () => ({ ok: true, status: 200, body: { serverId: TEST_SERVER_ID } }),
|
|
1953
|
+
});
|
|
1954
|
+
await nonOk.service.loadConfig();
|
|
1955
|
+
const nonOkResult = await nonOk.service.setConfig({ enabled: true, mode: 'private', httpsPort: 443 });
|
|
1956
|
+
expect(nonOkResult.state).toBe('starting');
|
|
1957
|
+
expect(nonOkResult.url).toBeNull();
|
|
1958
|
+
expect(nonOk.fallbackCalls).toEqual([]);
|
|
1959
|
+
nonOk.service.dispose();
|
|
1960
|
+
// Mismatching serverId direct response.
|
|
1961
|
+
const mismatch = createProbeService({
|
|
1962
|
+
fetchImpl: async () => ({ ok: true, status: 200, json: async () => ({ serverId: 'some-other-server' }) }),
|
|
1963
|
+
tailnetHealthFetch: async () => ({ ok: true, status: 200, body: { serverId: TEST_SERVER_ID } }),
|
|
1964
|
+
});
|
|
1965
|
+
await mismatch.service.loadConfig();
|
|
1966
|
+
const mismatchResult = await mismatch.service.setConfig({ enabled: true, mode: 'private', httpsPort: 443 });
|
|
1967
|
+
expect(mismatchResult.state).toBe('starting');
|
|
1968
|
+
expect(mismatchResult.url).toBeNull();
|
|
1969
|
+
expect(mismatch.fallbackCalls).toEqual([]);
|
|
1970
|
+
mismatch.service.dispose();
|
|
1971
|
+
});
|
|
1972
|
+
|
|
1973
|
+
it('stays starting when the tailnet path fails, without an unhandled rejection', async () => {
|
|
1974
|
+
const unhandled = [];
|
|
1975
|
+
const onUnhandled = (reason) => unhandled.push(reason);
|
|
1976
|
+
process.on('unhandledRejection', onUnhandled);
|
|
1977
|
+
const services = [];
|
|
1978
|
+
try {
|
|
1979
|
+
// Throwing fallback.
|
|
1980
|
+
const throwing = createProbeService({
|
|
1981
|
+
fetchImpl: directDnsFailure,
|
|
1982
|
+
tailnetHealthFetch: async () => { throw new Error('nc exploded'); },
|
|
1983
|
+
});
|
|
1984
|
+
services.push(throwing.service);
|
|
1985
|
+
await throwing.service.loadConfig();
|
|
1986
|
+
const throwingResult = await throwing.service.setConfig({ enabled: true, mode: 'private', httpsPort: 443 });
|
|
1987
|
+
expect(throwingResult.state).toBe('starting');
|
|
1988
|
+
expect(throwingResult.url).toBeNull();
|
|
1989
|
+
expect(throwing.fallbackCalls).toHaveLength(1);
|
|
1990
|
+
// Failing (non-throwing) fallback.
|
|
1991
|
+
const failing = createProbeService({
|
|
1992
|
+
fetchImpl: directDnsFailure,
|
|
1993
|
+
tailnetHealthFetch: async () => ({ ok: false, status: null, body: null, error: 'timeout' }),
|
|
1994
|
+
});
|
|
1995
|
+
services.push(failing.service);
|
|
1996
|
+
await failing.service.loadConfig();
|
|
1997
|
+
const failingResult = await failing.service.setConfig({ enabled: true, mode: 'private', httpsPort: 443 });
|
|
1998
|
+
expect(failingResult.state).toBe('starting');
|
|
1999
|
+
expect(failingResult.url).toBeNull();
|
|
2000
|
+
expect(failing.fallbackCalls).toHaveLength(1);
|
|
2001
|
+
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
2002
|
+
expect(unhandled).toEqual([]);
|
|
2003
|
+
} finally {
|
|
2004
|
+
process.removeListener('unhandledRejection', onUnhandled);
|
|
2005
|
+
for (const service of services) service.dispose();
|
|
2006
|
+
}
|
|
2007
|
+
});
|
|
2008
|
+
});
|
|
2009
|
+
|
|
2010
|
+
describe('tailscale nc health fetch', () => {
|
|
2011
|
+
it('reports a spawn failure instead of throwing', async () => {
|
|
2012
|
+
const fetch = createTailscaleNcHealthFetch({
|
|
2013
|
+
executable: 'tailscale',
|
|
2014
|
+
spawnFn: () => { throw new Error('spawn tailscale ENOENT'); },
|
|
2015
|
+
});
|
|
2016
|
+
const result = await fetch({ host: 'mymachine.tailabc.ts.net', port: 443, timeoutMs: 100 });
|
|
2017
|
+
expect(result).toEqual({ ok: false, status: null, body: null, error: 'spawn' });
|
|
2018
|
+
});
|
|
2019
|
+
|
|
2020
|
+
it('rejects an invalid target without spawning', async () => {
|
|
2021
|
+
const spawnFn = vi.fn();
|
|
2022
|
+
const fetch = createTailscaleNcHealthFetch({ executable: 'tailscale', spawnFn });
|
|
2023
|
+
const result = await fetch({ host: '', port: 443, timeoutMs: 100 });
|
|
2024
|
+
expect(result).toEqual({ ok: false, status: null, body: null, error: 'invalid-target' });
|
|
2025
|
+
expect(spawnFn).not.toHaveBeenCalled();
|
|
2026
|
+
});
|
|
2027
|
+
|
|
2028
|
+
it('kills the child when the probe times out', async () => {
|
|
2029
|
+
const { PassThrough } = await import('node:stream');
|
|
2030
|
+
const { EventEmitter } = await import('node:events');
|
|
2031
|
+
const children = [];
|
|
2032
|
+
const spawnFn = (command, args, options) => {
|
|
2033
|
+
expect(command).toBe('tailscale');
|
|
2034
|
+
expect(args).toEqual(['nc', 'mymachine.tailabc.ts.net', '443']);
|
|
2035
|
+
expect(options).toMatchObject({ windowsHide: true, shell: false });
|
|
2036
|
+
const child = new EventEmitter();
|
|
2037
|
+
child.stdout = new PassThrough();
|
|
2038
|
+
child.stdin = new PassThrough();
|
|
2039
|
+
child.kill = vi.fn();
|
|
2040
|
+
child.stdout.on('error', () => {});
|
|
2041
|
+
child.stdin.on('error', () => {});
|
|
2042
|
+
children.push(child);
|
|
2043
|
+
return child;
|
|
2044
|
+
};
|
|
2045
|
+
const fetch = createTailscaleNcHealthFetch({ executable: 'tailscale', spawnFn });
|
|
2046
|
+
// No handshake bytes ever arrive, so the probe must time out.
|
|
2047
|
+
const result = await fetch({ host: 'mymachine.tailabc.ts.net', port: 443, timeoutMs: 50 });
|
|
2048
|
+
expect(result.ok).toBe(false);
|
|
2049
|
+
expect(result.error).toBe('timeout');
|
|
2050
|
+
expect(children).toHaveLength(1);
|
|
2051
|
+
expect(children[0].kill).toHaveBeenCalledWith('SIGKILL');
|
|
2052
|
+
children[0].stdout.destroy();
|
|
2053
|
+
children[0].stdin.destroy();
|
|
2054
|
+
});
|
|
2055
|
+
|
|
2056
|
+
it('aborts on signal and kills the child', async () => {
|
|
2057
|
+
const { PassThrough } = await import('node:stream');
|
|
2058
|
+
const { EventEmitter } = await import('node:events');
|
|
2059
|
+
const children = [];
|
|
2060
|
+
const spawnFn = () => {
|
|
2061
|
+
const child = new EventEmitter();
|
|
2062
|
+
child.stdout = new PassThrough();
|
|
2063
|
+
child.stdin = new PassThrough();
|
|
2064
|
+
child.kill = vi.fn();
|
|
2065
|
+
child.stdout.on('error', () => {});
|
|
2066
|
+
child.stdin.on('error', () => {});
|
|
2067
|
+
children.push(child);
|
|
2068
|
+
return child;
|
|
2069
|
+
};
|
|
2070
|
+
const fetch = createTailscaleNcHealthFetch({ executable: 'tailscale', spawnFn });
|
|
2071
|
+
const controller = new AbortController();
|
|
2072
|
+
setTimeout(() => controller.abort(), 10);
|
|
2073
|
+
const result = await fetch({
|
|
2074
|
+
host: 'mymachine.tailabc.ts.net',
|
|
2075
|
+
port: 443,
|
|
2076
|
+
timeoutMs: 5_000,
|
|
2077
|
+
signal: controller.signal,
|
|
2078
|
+
});
|
|
2079
|
+
expect(result).toEqual({ ok: false, status: null, body: null, error: 'aborted' });
|
|
2080
|
+
expect(children).toHaveLength(1);
|
|
2081
|
+
expect(children[0].kill).toHaveBeenCalledWith('SIGKILL');
|
|
2082
|
+
children[0].stdout.destroy();
|
|
2083
|
+
children[0].stdin.destroy();
|
|
2084
|
+
});
|
|
2085
|
+
});
|
|
2086
|
+
|
|
2087
|
+
describe('tailscale public DNS readiness (funnel)', () => {
|
|
2088
|
+
const memFsFor = () => {
|
|
2089
|
+
const memFs = new Map();
|
|
2090
|
+
return {
|
|
2091
|
+
memFs,
|
|
2092
|
+
fsPromises: {
|
|
2093
|
+
readFile: async (p) => {
|
|
2094
|
+
if (!memFs.has(p)) { const e = new Error('x'); e.code = 'ENOENT'; throw e; }
|
|
2095
|
+
return memFs.get(p);
|
|
2096
|
+
},
|
|
2097
|
+
writeFile: async (p, c) => { memFs.set(p, String(c)); },
|
|
2098
|
+
mkdir: async () => {},
|
|
2099
|
+
rename: async (a, b) => { memFs.set(b, memFs.get(a)); memFs.delete(a); },
|
|
2100
|
+
unlink: async (p) => { memFs.delete(p); },
|
|
2101
|
+
},
|
|
2102
|
+
};
|
|
2103
|
+
};
|
|
2104
|
+
const flush = async (rounds = 5) => {
|
|
2105
|
+
for (let i = 0; i < rounds; i += 1) {
|
|
2106
|
+
await Promise.resolve();
|
|
2107
|
+
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
2108
|
+
}
|
|
2109
|
+
};
|
|
2110
|
+
const createPublicService = ({ dnsImpl, mode = 'public' } = {}) => {
|
|
2111
|
+
const { fsPromises } = memFsFor();
|
|
2112
|
+
const dnsCalls = [];
|
|
2113
|
+
const resolvePublicDns = async (hostname) => {
|
|
2114
|
+
dnsCalls.push(hostname);
|
|
2115
|
+
return dnsImpl(hostname);
|
|
2116
|
+
};
|
|
2117
|
+
const service = createTailscaleService({
|
|
2118
|
+
existsSync: () => false,
|
|
2119
|
+
dataDir: '/data',
|
|
2120
|
+
getPort: () => 3000,
|
|
2121
|
+
isUiAuthEnabled: () => true,
|
|
2122
|
+
isUnsafeUnauthenticatedLanAllowed: () => false,
|
|
2123
|
+
runner: {
|
|
2124
|
+
runTailscale: async (args) => {
|
|
2125
|
+
const sub = mode === 'public' ? 'funnel' : 'serve';
|
|
2126
|
+
if (args.includes(sub) && args.includes('status')) {
|
|
2127
|
+
return { ok: true, code: 0, stdout: JSON.stringify({ Web: {} }), stderr: '', spawnError: null, timedOut: false };
|
|
2128
|
+
}
|
|
2129
|
+
if (args.includes('serve') && args.includes('status')) {
|
|
2130
|
+
return { ok: true, code: 0, stdout: JSON.stringify({ Web: {} }), stderr: '', spawnError: null, timedOut: false };
|
|
2131
|
+
}
|
|
2132
|
+
if (args.includes('funnel') && args.includes('status')) {
|
|
2133
|
+
return { ok: true, code: 0, stdout: JSON.stringify({ Web: {} }), stderr: '', spawnError: null, timedOut: false };
|
|
2134
|
+
}
|
|
2135
|
+
return { ok: true, code: 0, stdout: STATUS_JSON, stderr: '', spawnError: null, timedOut: false };
|
|
2136
|
+
},
|
|
2137
|
+
},
|
|
2138
|
+
fsPromises,
|
|
2139
|
+
getServerId: async () => TEST_SERVER_ID,
|
|
2140
|
+
fetchImpl: matchingFetchImpl,
|
|
2141
|
+
resolvePublicDns,
|
|
2142
|
+
logWarn: () => {},
|
|
2143
|
+
});
|
|
2144
|
+
return { service, dnsCalls };
|
|
2145
|
+
};
|
|
2146
|
+
|
|
2147
|
+
it('public active pending -> ready via interval with fake timers, then stops polling', async () => {
|
|
2148
|
+
vi.useFakeTimers();
|
|
2149
|
+
let dnsResult = 'not-found';
|
|
2150
|
+
const { service, dnsCalls } = createPublicService({ dnsImpl: async () => dnsResult });
|
|
2151
|
+
try {
|
|
2152
|
+
await service.loadConfig();
|
|
2153
|
+
const result = await service.setConfig({ enabled: true, mode: 'public', httpsPort: 443 });
|
|
2154
|
+
expect(result.state).toBe('active');
|
|
2155
|
+
// Immediate check runs async: flush it.
|
|
2156
|
+
await vi.advanceTimersByTimeAsync(0);
|
|
2157
|
+
expect(service.getStatus().publicDns).toBe('pending');
|
|
2158
|
+
expect(dnsCalls.length).toBe(1);
|
|
2159
|
+
// Still not found after one interval.
|
|
2160
|
+
await vi.advanceTimersByTimeAsync(30_000);
|
|
2161
|
+
expect(service.getStatus().publicDns).toBe('pending');
|
|
2162
|
+
expect(dnsCalls.length).toBe(2);
|
|
2163
|
+
// Record appears: next interval flips to ready and stops.
|
|
2164
|
+
dnsResult = 'found';
|
|
2165
|
+
await vi.advanceTimersByTimeAsync(30_000);
|
|
2166
|
+
expect(service.getStatus().publicDns).toBe('ready');
|
|
2167
|
+
const callsAtReady = dnsCalls.length;
|
|
2168
|
+
await vi.advanceTimersByTimeAsync(10 * 60_000);
|
|
2169
|
+
expect(dnsCalls.length).toBe(callsAtReady);
|
|
2170
|
+
expect(service.getStatus().publicDns).toBe('ready');
|
|
2171
|
+
} finally {
|
|
2172
|
+
service.dispose();
|
|
2173
|
+
vi.useRealTimers();
|
|
2174
|
+
}
|
|
2175
|
+
});
|
|
2176
|
+
|
|
2177
|
+
it('error maps to unknown and recovers to pending then ready', async () => {
|
|
2178
|
+
vi.useFakeTimers();
|
|
2179
|
+
let dnsResult = 'error';
|
|
2180
|
+
const { service, dnsCalls } = createPublicService({ dnsImpl: async () => dnsResult });
|
|
2181
|
+
try {
|
|
2182
|
+
await service.loadConfig();
|
|
2183
|
+
await service.setConfig({ enabled: true, mode: 'public', httpsPort: 443 });
|
|
2184
|
+
await vi.advanceTimersByTimeAsync(0);
|
|
2185
|
+
expect(service.getStatus().publicDns).toBe('unknown');
|
|
2186
|
+
dnsResult = 'not-found';
|
|
2187
|
+
await vi.advanceTimersByTimeAsync(30_000);
|
|
2188
|
+
expect(service.getStatus().publicDns).toBe('pending');
|
|
2189
|
+
dnsResult = 'found';
|
|
2190
|
+
await vi.advanceTimersByTimeAsync(30_000);
|
|
2191
|
+
expect(service.getStatus().publicDns).toBe('ready');
|
|
2192
|
+
expect(dnsCalls.length).toBeGreaterThanOrEqual(3);
|
|
2193
|
+
} finally {
|
|
2194
|
+
service.dispose();
|
|
2195
|
+
vi.useRealTimers();
|
|
2196
|
+
}
|
|
2197
|
+
});
|
|
2198
|
+
|
|
2199
|
+
it('private active never queries DNS and reports null', async () => {
|
|
2200
|
+
const { service, dnsCalls } = createPublicService({ dnsImpl: async () => 'found', mode: 'private' });
|
|
2201
|
+
try {
|
|
2202
|
+
await service.loadConfig();
|
|
2203
|
+
const result = await service.setConfig({ enabled: true, mode: 'private', httpsPort: 443 });
|
|
2204
|
+
expect(result.state).toBe('active');
|
|
2205
|
+
expect(result.publicDns).toBeNull();
|
|
2206
|
+
await flush();
|
|
2207
|
+
expect(dnsCalls).toEqual([]);
|
|
2208
|
+
expect(service.getStatus().publicDns).toBeNull();
|
|
2209
|
+
} finally {
|
|
2210
|
+
service.dispose();
|
|
2211
|
+
}
|
|
2212
|
+
});
|
|
2213
|
+
|
|
2214
|
+
it('non-active states report null (off)', async () => {
|
|
2215
|
+
const { service } = createHarness({
|
|
2216
|
+
handlers: {
|
|
2217
|
+
'status --json': { ok: true, code: 0, stdout: STATUS_JSON, stderr: '', spawnError: null, timedOut: false },
|
|
2218
|
+
},
|
|
2219
|
+
});
|
|
2220
|
+
try {
|
|
2221
|
+
await service.loadConfig();
|
|
2222
|
+
expect(service.getStatus().publicDns).toBeNull();
|
|
2223
|
+
const off = await service.reconcile();
|
|
2224
|
+
expect(off.state).toBe('off');
|
|
2225
|
+
expect(off.publicDns).toBeNull();
|
|
2226
|
+
} finally {
|
|
2227
|
+
service.dispose();
|
|
2228
|
+
}
|
|
2229
|
+
});
|
|
2230
|
+
|
|
2231
|
+
it('mode switch public->private stops the watcher and reports null', async () => {
|
|
2232
|
+
vi.useFakeTimers();
|
|
2233
|
+
let dnsResult = 'not-found';
|
|
2234
|
+
const { service, dnsCalls } = createPublicService({ dnsImpl: async () => dnsResult });
|
|
2235
|
+
try {
|
|
2236
|
+
await service.loadConfig();
|
|
2237
|
+
await service.setConfig({ enabled: true, mode: 'public', httpsPort: 443 });
|
|
2238
|
+
await vi.advanceTimersByTimeAsync(0);
|
|
2239
|
+
expect(service.getStatus().publicDns).toBe('pending');
|
|
2240
|
+
const callsBefore = dnsCalls.length;
|
|
2241
|
+
await service.setConfig({ enabled: true, mode: 'private', httpsPort: 443 });
|
|
2242
|
+
expect(service.getStatus().publicDns).toBeNull();
|
|
2243
|
+
await vi.advanceTimersByTimeAsync(5 * 60_000);
|
|
2244
|
+
expect(dnsCalls.length).toBe(callsBefore);
|
|
2245
|
+
expect(service.getStatus().publicDns).toBeNull();
|
|
2246
|
+
} finally {
|
|
2247
|
+
service.dispose();
|
|
2248
|
+
vi.useRealTimers();
|
|
2249
|
+
}
|
|
2250
|
+
});
|
|
2251
|
+
|
|
2252
|
+
it('disable stops the watcher; a stale resolve never writes after the generation bump', async () => {
|
|
2253
|
+
let releaseDns = null;
|
|
2254
|
+
const gate = new Promise((resolve) => { releaseDns = resolve; });
|
|
2255
|
+
const { fsPromises } = memFsFor();
|
|
2256
|
+
const dnsCalls = [];
|
|
2257
|
+
const service = createTailscaleService({
|
|
2258
|
+
existsSync: () => false,
|
|
2259
|
+
dataDir: '/data',
|
|
2260
|
+
getPort: () => 3000,
|
|
2261
|
+
isUiAuthEnabled: () => true,
|
|
2262
|
+
isUnsafeUnauthenticatedLanAllowed: () => false,
|
|
2263
|
+
runner: {
|
|
2264
|
+
runTailscale: async (args) => {
|
|
2265
|
+
if (args.includes('funnel') && args.includes('status')) {
|
|
2266
|
+
return { ok: true, code: 0, stdout: JSON.stringify({ Web: {} }), stderr: '', spawnError: null, timedOut: false };
|
|
2267
|
+
}
|
|
2268
|
+
if (args.includes('serve') && args.includes('status')) {
|
|
2269
|
+
return { ok: true, code: 0, stdout: JSON.stringify({ Web: {} }), stderr: '', spawnError: null, timedOut: false };
|
|
2270
|
+
}
|
|
2271
|
+
return { ok: true, code: 0, stdout: STATUS_JSON, stderr: '', spawnError: null, timedOut: false };
|
|
2272
|
+
},
|
|
2273
|
+
},
|
|
2274
|
+
fsPromises,
|
|
2275
|
+
getServerId: async () => TEST_SERVER_ID,
|
|
2276
|
+
fetchImpl: matchingFetchImpl,
|
|
2277
|
+
resolvePublicDns: async (hostname) => {
|
|
2278
|
+
dnsCalls.push(hostname);
|
|
2279
|
+
await gate;
|
|
2280
|
+
return 'found';
|
|
2281
|
+
},
|
|
2282
|
+
logWarn: () => {},
|
|
2283
|
+
});
|
|
2284
|
+
try {
|
|
2285
|
+
await service.loadConfig();
|
|
2286
|
+
const active = await service.setConfig({ enabled: true, mode: 'public', httpsPort: 443 });
|
|
2287
|
+
expect(active.state).toBe('active');
|
|
2288
|
+
expect(active.publicDns).toBe('pending');
|
|
2289
|
+
// Bump the generation while the immediate DNS check is in flight.
|
|
2290
|
+
const disabled = await service.setConfig({ enabled: false });
|
|
2291
|
+
expect(disabled.state).toBe('off');
|
|
2292
|
+
expect(disabled.publicDns).toBeNull();
|
|
2293
|
+
// Late DNS success must not resurrect publicDns.
|
|
2294
|
+
releaseDns();
|
|
2295
|
+
await flush(10);
|
|
2296
|
+
expect(service.getStatus().state).toBe('off');
|
|
2297
|
+
expect(service.getStatus().publicDns).toBeNull();
|
|
2298
|
+
} finally {
|
|
2299
|
+
try { releaseDns?.(); } catch {}
|
|
2300
|
+
service.dispose();
|
|
2301
|
+
}
|
|
2302
|
+
});
|
|
2303
|
+
|
|
2304
|
+
it('shutdown stops the watcher: no further resolver calls', async () => {
|
|
2305
|
+
vi.useFakeTimers();
|
|
2306
|
+
let dnsResult = 'not-found';
|
|
2307
|
+
const { service, dnsCalls } = createPublicService({ dnsImpl: async () => dnsResult });
|
|
2308
|
+
try {
|
|
2309
|
+
await service.loadConfig();
|
|
2310
|
+
await service.setConfig({ enabled: true, mode: 'public', httpsPort: 443 });
|
|
2311
|
+
await vi.advanceTimersByTimeAsync(0);
|
|
2312
|
+
expect(service.getStatus().publicDns).toBe('pending');
|
|
2313
|
+
const callsBefore = dnsCalls.length;
|
|
2314
|
+
await service.shutdown();
|
|
2315
|
+
await vi.advanceTimersByTimeAsync(5 * 60_000);
|
|
2316
|
+
expect(dnsCalls.length).toBe(callsBefore);
|
|
2317
|
+
} finally {
|
|
2318
|
+
service.dispose();
|
|
2319
|
+
vi.useRealTimers();
|
|
2320
|
+
}
|
|
2321
|
+
});
|
|
2322
|
+
|
|
2323
|
+
it('interval backs off to 2 minutes after 20 minutes', async () => {
|
|
2324
|
+
vi.useFakeTimers();
|
|
2325
|
+
const { service, dnsCalls } = createPublicService({ dnsImpl: async () => 'not-found' });
|
|
2326
|
+
try {
|
|
2327
|
+
await service.loadConfig();
|
|
2328
|
+
await service.setConfig({ enabled: true, mode: 'public', httpsPort: 443 });
|
|
2329
|
+
await vi.advanceTimersByTimeAsync(0);
|
|
2330
|
+
expect(dnsCalls.length).toBe(1);
|
|
2331
|
+
// 30s cadence for the first 20 minutes: 40 intervals reach t=20min.
|
|
2332
|
+
for (let i = 0; i < 40; i += 1) {
|
|
2333
|
+
await vi.advanceTimersByTimeAsync(30_000);
|
|
2334
|
+
}
|
|
2335
|
+
const callsAt20min = dnsCalls.length;
|
|
2336
|
+
expect(callsAt20min).toBe(1 + 40);
|
|
2337
|
+
// After 20 minutes the cadence is 2 minutes: +30s is not enough.
|
|
2338
|
+
await vi.advanceTimersByTimeAsync(30_000);
|
|
2339
|
+
expect(dnsCalls.length).toBe(callsAt20min);
|
|
2340
|
+
await vi.advanceTimersByTimeAsync(90_000);
|
|
2341
|
+
expect(dnsCalls.length).toBe(callsAt20min + 1);
|
|
2342
|
+
} finally {
|
|
2343
|
+
service.dispose();
|
|
2344
|
+
vi.useRealTimers();
|
|
2345
|
+
}
|
|
2346
|
+
});
|
|
2347
|
+
});
|
|
2348
|
+
|
|
2349
|
+
describe('public-dns resolver mapping', () => {
|
|
2350
|
+
it('maps answers, NXDOMAIN/NODATA, and failures without touching the network', async () => {
|
|
2351
|
+
const { createResolvePublicDns } = await import('./public-dns.js');
|
|
2352
|
+
const scripted = ({ v4, v6 }) => {
|
|
2353
|
+
const calls = [];
|
|
2354
|
+
const resolve = createResolvePublicDns({
|
|
2355
|
+
createResolver: () => ({
|
|
2356
|
+
setServers: () => {},
|
|
2357
|
+
cancel: () => {},
|
|
2358
|
+
resolve4: async () => {
|
|
2359
|
+
calls.push('v4');
|
|
2360
|
+
if (v4 instanceof Error) throw v4;
|
|
2361
|
+
return v4;
|
|
2362
|
+
},
|
|
2363
|
+
resolve6: async () => {
|
|
2364
|
+
calls.push('v6');
|
|
2365
|
+
if (v6 instanceof Error) throw v6;
|
|
2366
|
+
return v6;
|
|
2367
|
+
},
|
|
2368
|
+
}),
|
|
2369
|
+
});
|
|
2370
|
+
return { resolve, calls };
|
|
2371
|
+
};
|
|
2372
|
+
const notFound4 = Object.assign(new Error('queryA ENOTFOUND m.ts.net'), { code: 'ENOTFOUND' });
|
|
2373
|
+
const noData6 = Object.assign(new Error('queryAaaa ENODATA m.ts.net'), { code: 'ENODATA' });
|
|
2374
|
+
// Any address -> found.
|
|
2375
|
+
{
|
|
2376
|
+
const { resolve: resolveFound } = scripted({ v4: ['93.184.216.34'], v6: noData6 });
|
|
2377
|
+
expect(await resolveFound('m.ts.net')).toBe('found');
|
|
2378
|
+
}
|
|
2379
|
+
// All NXDOMAIN/NODATA -> not-found.
|
|
2380
|
+
{
|
|
2381
|
+
const { resolve: resolveNotFound } = scripted({ v4: notFound4, v6: noData6 });
|
|
2382
|
+
expect(await resolveNotFound('m.ts.net')).toBe('not-found');
|
|
2383
|
+
}
|
|
2384
|
+
// Timeout/refused -> error.
|
|
2385
|
+
{
|
|
2386
|
+
const timeout = Object.assign(new Error('queryA ETIMEOUT m.ts.net'), { code: 'ETIMEOUT' });
|
|
2387
|
+
const { resolve: resolveError } = scripted({ v4: timeout, v6: noData6 });
|
|
2388
|
+
expect(await resolveError('m.ts.net')).toBe('error');
|
|
2389
|
+
}
|
|
2390
|
+
// Never throws on bad input.
|
|
2391
|
+
{
|
|
2392
|
+
const { resolve: resolveBad } = scripted({ v4: ['1.1.1.1'], v6: ['::1'] });
|
|
2393
|
+
expect(await resolveBad('')).toBe('error');
|
|
2394
|
+
expect(await resolveBad(null)).toBe('error');
|
|
2395
|
+
}
|
|
2396
|
+
});
|
|
2397
|
+
});
|