mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
Typed chat sessions no longer end on the voice inactivity timeout, and a failed or stopped reply keeps the conversation: Stop cancels only the reply in progress, and map actions that already ran stay in the model's context. Each upstream request and map action gets its own deadline, old tool results shrink instead of the history overflowing, and step limits, a missing or rejected key, the OAuth lock and throttling each get their own message. - Server: OpenAI chat is off under GEV_PREFER_CODEX_OAUTH; chat throttles default to the provider's throttle; replies carry API_KEY_MISSING, API_KEY_REJECTED, CODEX_OAUTH_REQUIRED and RATE_LIMITED codes; upstream Retry-After passes through, and a rejected key (Gemini's invalid-key 400 included) cools down for a minute - Pinokio forwards the chat throttle settings - UI: the reply reveal publishes only the message list; the border orbit runs only while busy; layers attach with a button or Enter; the log is aria-busy while a reply types out; auto-scroll respects a reader who scrolled up; Escape closes the attach menu; the chat gear says Settings; a note says chat bills the OpenAI key when voice uses ChatGPT sign-in - Layout does less work while panel height animates; unused blurs removed - Gemini voice start ends chat; the voice preview clears on every new session - Tests for the route gates, client limits, attachments and the fixes
245 lines
9.8 KiB
JavaScript
245 lines
9.8 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { realpathSync } from 'node:fs';
|
|
import { access, copyFile, mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
|
|
import { createRequire } from 'node:module';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import test from 'node:test';
|
|
import { isDirectInvocation } from '../scripts/pinokio-install.mjs';
|
|
import { loadViteFromCanonicalRoot } from '../scripts/pinokio-start.mjs';
|
|
|
|
const require = createRequire(import.meta.url);
|
|
|
|
const PROVIDER_FIELDS = [
|
|
'GOOGLE_MAPS_API_KEY',
|
|
'GOOGLE_MAPS_SERVER_API_KEY',
|
|
'CESIUM_ION_TOKEN',
|
|
'OPENAI_API_KEY',
|
|
'AISSTREAM_API_KEY',
|
|
'FIRMS_MAP_KEY',
|
|
'TOMTOM_API_KEY',
|
|
'OPENSKY_CLIENT_ID',
|
|
'OPENSKY_CLIENT_SECRET',
|
|
'LL2_API_TOKEN',
|
|
];
|
|
const RATE_LIMIT_FIELDS = [
|
|
'GEV_RATELIMIT_OPENAI_PER_MIN',
|
|
'GEV_RATELIMIT_GOOGLE_PER_MIN',
|
|
'GEV_RATELIMIT_OPENAI_CHAT_PER_MIN',
|
|
'GEV_RATELIMIT_GEMINI_CHAT_PER_MIN',
|
|
];
|
|
const APP_VALUE_FIELDS = [...PROVIDER_FIELDS, ...RATE_LIMIT_FIELDS];
|
|
const SHARING_FIELDS = [
|
|
'PINOKIO_SHARE_CLOUDFLARE',
|
|
'PINOKIO_SHARE_LOCAL',
|
|
'PINOKIO_SHARE_VAR',
|
|
];
|
|
|
|
function assertAppFieldForwarded(env, field) {
|
|
assert.equal(env[field], `{{env.${field} || ""}}`);
|
|
}
|
|
|
|
test('Pinokio start has one fail-closed launcher process', () => {
|
|
const script = require('../pinokio/start.js');
|
|
assert.equal(script.run[0].params.message, 'node scripts/pinokio-start.mjs');
|
|
assert.equal(Array.isArray(script.run[0].params.message), false);
|
|
assert.match(script.run[0].params.on[0].event, /\\\[Pinokio\\\] Ready at/);
|
|
for (const field of APP_VALUE_FIELDS) {
|
|
assertAppFieldForwarded(script.run[0].params.env, field);
|
|
}
|
|
assert.equal('PINOKIO_SHARE_PASSCODE' in script.run[0].params.env, false);
|
|
assert.equal(
|
|
script.run[0].params.env.PINOKIO_SHARE_CLOUDFLARE,
|
|
'{{env.PINOKIO_SHARE_CLOUDFLARE || "false"}}',
|
|
);
|
|
assert.equal(
|
|
script.run[0].params.env.PINOKIO_SHARE_LOCAL,
|
|
'{{env.PINOKIO_SHARE_LOCAL || "false"}}',
|
|
);
|
|
assert.equal(
|
|
script.run[0].params.env.PINOKIO_SHARE_VAR,
|
|
'{{env.PINOKIO_SHARE_VAR || "__gev_sharing_disabled__"}}',
|
|
);
|
|
});
|
|
|
|
test('Pinokio install records success explicitly instead of trusting node_modules', async () => {
|
|
const install = require('../pinokio/install.js');
|
|
const fs = await import('node:fs/promises');
|
|
const installSource = await fs.readFile(new URL('../scripts/pinokio-install.mjs', import.meta.url), 'utf8');
|
|
assert.equal(install.run.at(-1).params.message, 'node scripts/pinokio-install.mjs');
|
|
assert.equal(install.run[0].when, "{{!kernel.exists(cwd, 'ENVIRONMENT')}}");
|
|
assert.match(installSource, /includeKeychain: false/);
|
|
assert.match(installSource, /authoritativeEnvironment: true/);
|
|
assert.match(installSource, /applyPinokioEnvironment\(\)/);
|
|
assert.match(installSource, /Return to Pinokio and choose Start/);
|
|
for (const field of APP_VALUE_FIELDS) {
|
|
assertAppFieldForwarded(install.run.at(-1).params.env, field);
|
|
}
|
|
for (const field of SHARING_FIELDS) {
|
|
assert.equal(field in install.run.at(-1).params.env, false);
|
|
}
|
|
});
|
|
|
|
test('Pinokio menu resolves the nested install marker and exposes each lifecycle state', async (t) => {
|
|
const fixture = await mkdtemp(path.join(os.tmpdir(), 'gev-pinokio-menu-'));
|
|
t.after(() => rm(fixture, { recursive: true, force: true }));
|
|
const launcherDir = path.join(fixture, 'app', 'pinokio');
|
|
const launcherPath = path.join(launcherDir, 'pinokio.js');
|
|
const markerPath = path.join(launcherDir, '.installed');
|
|
await mkdir(launcherDir, { recursive: true });
|
|
await copyFile(new URL('../pinokio/pinokio.js', import.meta.url), launcherPath);
|
|
|
|
const existsCalls = [];
|
|
const kernel = {
|
|
exists: async (...chunks) => {
|
|
existsCalls.push(chunks);
|
|
try {
|
|
await access(path.resolve(...chunks));
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
},
|
|
};
|
|
const runtime = { running: null, url: null };
|
|
const info = {
|
|
exists: () => assert.fail('menu must resolve the marker through kernel.exists'),
|
|
running: (href) => runtime.running === href,
|
|
local: () => runtime.url ? { url: runtime.url } : {},
|
|
};
|
|
const { menu } = require(launcherPath);
|
|
const render = async ({ installed, running = null, url = null }) => {
|
|
if (installed) await writeFile(markerPath, 'ready\n');
|
|
else await rm(markerPath, { force: true });
|
|
runtime.running = running;
|
|
runtime.url = url;
|
|
const items = await menu(kernel, info);
|
|
assert.equal(items.filter((item) => item.default).length, 1);
|
|
const ready = installed && running === 'start.js' && Boolean(url);
|
|
assert.equal(items[0].popout, ready ? true : undefined);
|
|
assert.ok(items.slice(1).every((item) => item.popout === undefined));
|
|
return items.map(({ text, href, default: isDefault = false }) => ({ text, href, default: isDefault }));
|
|
};
|
|
|
|
assert.deepEqual(await render({ installed: false }), [
|
|
{ text: 'Install', href: 'install.js', default: true },
|
|
]);
|
|
assert.deepEqual(await render({ installed: true }), [
|
|
{ text: 'Start', href: 'start.js', default: true },
|
|
{ text: 'Update', href: 'update.js', default: false },
|
|
{ text: 'Repair installation', href: 'reset.js', default: false },
|
|
]);
|
|
for (const [running, text] of [
|
|
['install.js', 'Installing'],
|
|
['update.js', 'Updating'],
|
|
['reset.js', 'Resetting'],
|
|
]) {
|
|
assert.deepEqual(await render({ installed: true, running }), [
|
|
{ text, href: running, default: true },
|
|
]);
|
|
}
|
|
assert.deepEqual(await render({ installed: true, running: 'start.js' }), [
|
|
{ text: 'Starting', href: 'start.js', default: true },
|
|
]);
|
|
assert.deepEqual(await render({
|
|
installed: true,
|
|
running: 'start.js',
|
|
url: 'http://127.0.0.1:4173/',
|
|
}), [
|
|
{ text: "Open God's Eye View", href: 'http://127.0.0.1:4173/', default: true },
|
|
{ text: 'Server', href: 'start.js', default: false },
|
|
]);
|
|
assert.ok(existsCalls.length >= 7);
|
|
const resolvedLauncherDir = realpathSync(launcherDir);
|
|
for (const chunks of existsCalls) {
|
|
assert.deepEqual(chunks, [resolvedLauncherDir, '.installed']);
|
|
}
|
|
});
|
|
|
|
test('Pinokio install recognizes direct execution through a linked app directory', async (t) => {
|
|
const fixture = await mkdtemp(path.join(os.tmpdir(), 'gev-pinokio-entry-'));
|
|
t.after(() => rm(fixture, { recursive: true, force: true }));
|
|
const target = path.join(fixture, 'candidate');
|
|
const linked = path.join(fixture, 'installed-app');
|
|
const other = path.join(fixture, 'other-install.mjs');
|
|
const modulePath = path.join(target, 'scripts', 'pinokio-install.mjs');
|
|
await mkdir(path.dirname(modulePath), { recursive: true });
|
|
await writeFile(modulePath, '');
|
|
await writeFile(other, '');
|
|
await symlink(target, linked, process.platform === 'win32' ? 'junction' : 'dir');
|
|
|
|
assert.equal(isDirectInvocation(
|
|
path.join(linked, 'scripts', 'pinokio-install.mjs'),
|
|
modulePath,
|
|
), true);
|
|
assert.equal(isDirectInvocation(other, modulePath), false);
|
|
});
|
|
|
|
test('Pinokio direct execution fallback remains exact and Update-safe', () => {
|
|
const missing = path.join(os.tmpdir(), 'gev-missing-pinokio-install.mjs');
|
|
const differentMissing = path.join(os.tmpdir(), 'gev-other-missing-pinokio-install.mjs');
|
|
const updatePath = path.resolve('scripts/pinokio-update.mjs');
|
|
const installPath = path.resolve('scripts/pinokio-install.mjs');
|
|
|
|
assert.equal(isDirectInvocation(missing, missing), true);
|
|
assert.equal(isDirectInvocation(differentMissing, missing), false);
|
|
assert.equal(isDirectInvocation(updatePath, installPath), false);
|
|
assert.equal(isDirectInvocation('', installPath), false);
|
|
});
|
|
|
|
test('Pinokio Update forwards the app fields used by its install doctor', () => {
|
|
const update = require('../pinokio/update.js');
|
|
assert.equal(update.run[0].params.message, 'node scripts/pinokio-update.mjs');
|
|
for (const field of APP_VALUE_FIELDS) {
|
|
assertAppFieldForwarded(update.run[0].params.env, field);
|
|
}
|
|
for (const field of SHARING_FIELDS) {
|
|
assert.equal(field in update.run[0].params.env, false);
|
|
}
|
|
});
|
|
|
|
test('Pinokio start runner emits an ANSI-independent ready URL', async () => {
|
|
const source = await import('node:fs/promises')
|
|
.then((fs) => fs.readFile(new URL('../scripts/pinokio-start.mjs', import.meta.url), 'utf8'));
|
|
assert.match(source, /\[Pinokio\] Ready at http:\/\/127\.0\.0\.1:\$\{port\}\//);
|
|
assert.match(source, /applyPinokioEnvironment\(\)/);
|
|
assert.match(source, /loadViteFromCanonicalRoot\(\)/);
|
|
assert.ok(
|
|
source.indexOf('loadViteFromCanonicalRoot()') < source.indexOf('createServer({'),
|
|
);
|
|
});
|
|
|
|
test('Pinokio start enters the canonical app root before loading Vite', async (t) => {
|
|
const fixture = await mkdtemp(path.join(os.tmpdir(), 'gev-pinokio-root-'));
|
|
const originalCwd = process.cwd();
|
|
t.after(async () => {
|
|
process.chdir(originalCwd);
|
|
await rm(fixture, { recursive: true, force: true });
|
|
});
|
|
const target = path.join(fixture, 'candidate');
|
|
const linked = path.join(fixture, 'installed-app');
|
|
await mkdir(target, { recursive: true });
|
|
await symlink(target, linked, process.platform === 'win32' ? 'junction' : 'dir');
|
|
const sentinel = { createServer: Symbol('createServer') };
|
|
|
|
const loaded = await loadViteFromCanonicalRoot(linked, async () => {
|
|
assert.equal(process.cwd(), realpathSync(target));
|
|
return sentinel;
|
|
});
|
|
|
|
assert.equal(loaded, sentinel);
|
|
});
|
|
|
|
test('Pinokio keeps the supported local.url readiness key while disabling its share trigger', async () => {
|
|
const script = require('../pinokio/start.js');
|
|
const menuSource = await import('node:fs/promises')
|
|
.then((fs) => fs.readFile(new URL('../pinokio/pinokio.js', import.meta.url), 'utf8'));
|
|
assert.equal(script.run[1].method, 'local.set');
|
|
assert.equal(script.run[1].params.url, '{{input.event[1]}}');
|
|
assert.match(menuSource, /local\?\.url/);
|
|
assert.equal(
|
|
script.run[0].params.env.PINOKIO_SHARE_VAR,
|
|
'{{env.PINOKIO_SHARE_VAR || "__gev_sharing_disabled__"}}',
|
|
);
|
|
});
|