windows-development-sandbox 1.18.4 → 1.23.0

package/dist/host/profile/claude-login.js

@@ -9,23 +9,13 @@
 // written through. A key read from the sandbox must have the shape of an API key.
 import fs from 'node:fs';
 import path from 'node:path';
+import { anthropicKeyProblem } from '../../shared/accounts/index.js';
 import { assertTestWritable } from '../test-guard.js';
 import { hostDataFolder, hostDataRoot } from '../storage/index.js';
 import { assertNoLinks, fail, fileExists, isLink, removeLink, tryReadJson, writeJson } from '../../core/util/index.js';
 export const LOGIN_KINDS = ['subscription', 'console', 'api-key'];
-/** sk-ant-api03-...: a normal Anthropic API key (letters, digits, - and _, which is what Claude Code accepts). */
-const API_KEY = /^sk-ant-api\d{2}-[A-Za-z0-9_-]{20,400}$/;
-const API_USER_KEY = /^sk-ant-usr\d{2}-[A-Za-z0-9_-]{20,400}$/;
-/** What is wrong with a typed or found API key, or null when it has the right shape. Never quotes the key. */
-export function apiKeyProblem(key) {
-    if (API_KEY.test(key) || API_USER_KEY.test(key))
-        return null;
-    if (key.startsWith('sk-ant-oat'))
-        return 'That is a Claude subscription token (from claude setup-token), not an API key. Save the subscription login instead.';
-    if (key.startsWith('sk-ant-admin'))
-        return 'That is an Admin key: it cannot run Claude. Make an API key instead.';
-    return 'An Anthropic API key starts with sk-ant-api or sk-ant-usr and has only letters, digits, - and _ (copy it from the Claude Console).';
-}
+/** What is wrong with a typed or found API key (sk-ant-api or sk-ant-usr), or null. Never quotes the key. */
+export const apiKeyProblem = anthropicKeyProblem;
 /** The most of a key that is ever shown: sk-ant-...abcd. */
 export function maskApiKey(key) {
     return 'sk-ant-...' + key.slice(-4);

package/dist/host/vpn/index.d.ts

@@ -1,4 +1,5 @@
-export { VpnLogin, loginProblem, type LoginState, type VpnCredentials } from './login.js';
+export { VpnLogin, loginProblem, loginWarning, type LoginState, type VpnCredentials } from './login.js';
 export { fetchBounded, findCountry, nordProfile, recommendedServer, type Fetcher, type NordServer } from './nordvpn.js';
 export { prepareVpn, vpnNotes, wireguardFileProblem, type PrepareOptions } from './prepare.js';
 export { hostPublicIp, readVpnLine, vpnLine, type VpnLine } from './status.js';
+export { readLastFailure, recordLastVpn, type LastVpn, type VpnFailureInfo } from './last.js';

package/dist/host/vpn/index.js

@@ -1,4 +1,5 @@
-export { VpnLogin, loginProblem } from './login.js';
+export { VpnLogin, loginProblem, loginWarning } from './login.js';
 export { fetchBounded, findCountry, nordProfile, recommendedServer } from './nordvpn.js';
 export { prepareVpn, vpnNotes, wireguardFileProblem } from './prepare.js';
 export { hostPublicIp, readVpnLine, vpnLine } from './status.js';
+export { readLastFailure, recordLastVpn } from './last.js';

package/dist/host/vpn/last.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+declare const LastSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        failed: "failed";
+        up: "up";
+    }>;
+    code: z.ZodOptional<z.ZodEnum<{
+        auth: "auth";
+        unreachable: "unreachable";
+        driver: "driver";
+        timeout: "timeout";
+        other: "other";
+    }>>;
+    message: z.ZodString;
+    at: z.ZodString;
+}, z.core.$strip>;
+export type LastVpn = z.output<typeof LastSchema>;
+/** What the page shows for a failure: the plain sentence, never the raw log. */
+export interface VpnFailureInfo {
+    readonly code: NonNullable<LastVpn['code']>;
+    readonly text: string;
+    readonly at: string;
+}
+/** Copies the sandbox's final VPN state to host storage (nothing when the VPN was off). Never throws. */
+export declare function recordLastVpn(storageRoot: string, dataPath: string): void;
+/** The last attempt, when it failed (null when it worked or none is known). */
+export declare function readLastFailure(storageRoot: string): VpnFailureInfo | null;
+export {};

package/dist/host/vpn/last.js

@@ -0,0 +1,43 @@
+// The last VPN result of a sandbox, kept in host storage (<storage>\vpn\last.json) when the sandbox closes, so "the
+// login was refused" can still be shown after the sandbox is gone. Read from the sandbox's run\vpn.json (validated),
+// never from anything else the guest wrote; the text is made safe before it is kept.
+import path from 'node:path';
+import { z } from 'zod';
+import { RunDir } from '../../shared/channel/index.js';
+import { JsonFile } from '../../shared/io/index.js';
+import { FAILURE_TEXT } from '../../shared/vpn/failure.js';
+import { safeText } from '../../core/util/index.js';
+const LastSchema = z.object({
+    state: z.enum(['up', 'failed']),
+    code: z.enum(['auth', 'unreachable', 'driver', 'timeout', 'other']).optional(),
+    message: z.string().max(400),
+    at: z.string().max(64),
+});
+function lastFile(storageRoot) {
+    return new JsonFile(LastSchema, path.join(storageRoot, 'vpn', 'last.json'));
+}
+/** Copies the sandbox's final VPN state to host storage (nothing when the VPN was off). Never throws. */
+export function recordLastVpn(storageRoot, dataPath) {
+    try {
+        const status = new RunDir(dataPath).readVpnStatus();
+        if (!status || (status.state !== 'up' && status.state !== 'failed'))
+            return;
+        lastFile(storageRoot).write({
+            state: status.state,
+            ...(status.code ? { code: status.code } : {}),
+            message: safeText(status.message).slice(0, 400),
+            at: status.updatedAt,
+        });
+    }
+    catch {
+        // Only a convenience for the page: a failure here must not hold the final sync up.
+    }
+}
+/** The last attempt, when it failed (null when it worked or none is known). */
+export function readLastFailure(storageRoot) {
+    const last = lastFile(storageRoot).read();
+    if (!last || last.state !== 'failed')
+        return null;
+    const code = last.code ?? 'other';
+    return { code, text: FAILURE_TEXT[code], at: last.at };
+}

package/dist/host/vpn/login.d.ts

@@ -7,7 +7,9 @@ export interface VpnCredentials {
 /** What `sandbox vpn status` may say about the login: never the values. */
 export type LoginState = 'none' | 'saved' | 'unreadable';
 /** The login must go on two lines of a file for OpenVPN, so no line breaks or other control characters. */
-export declare function loginProblem(c: VpnCredentials): string | null;
+export declare function loginProblem(c: VpnCredentials, provider?: VpnProvider): string | null;
+/** A hint (not a refusal) when a NordVPN login does not look like service credentials (letters and digits, ~24). */
+export declare function loginWarning(c: VpnCredentials, provider: VpnProvider): string | null;
 export declare class VpnLogin {
     private readonly storageRoot;
     private readonly secrets;

package/dist/host/vpn/login.js

@@ -14,16 +14,30 @@ const SavedSchema = z.object({
     sealed: z.string().max(10000),
 });
 /** The login must go on two lines of a file for OpenVPN, so no line breaks or other control characters. */
-export function loginProblem(c) {
+export function loginProblem(c, provider) {
     const clean = (v) => !/[\u0000-\u001f\u007f]/.test(v);
     if (!c.username.trim() || !c.password)
         return 'Both the user name and the password are needed.';
     if (!clean(c.username) || !clean(c.password))
         return 'The login may not contain line breaks or control characters.';
+    // The markers a terminal puts around pasted text ([200~ ... [201~) are not part of any login.
+    if (/\[20[01]~/.test(c.username + c.password))
+        return 'The login has hidden paste characters in it (the terminal added them when you pasted).';
     if (c.username.length > 256 || c.password.length > 1024)
         return 'The user name or password is too long.';
+    if (provider === 'nordvpn' && /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(c.username.trim()))
+        return 'That looks like your NordVPN account e-mail. Use the service credentials: Nord Account > NordVPN > Manual setup.';
     return null;
 }
+/** A hint (not a refusal) when a NordVPN login does not look like service credentials (letters and digits, ~24). */
+export function loginWarning(c, provider) {
+    if (provider !== 'nordvpn')
+        return null;
+    const ok = (v) => /^[A-Za-z0-9]{16,64}$/.test(v.trim());
+    return ok(c.username) && ok(c.password)
+        ? null
+        : 'NordVPN service credentials are letters and digits only (about 24 each). If the VPN says the login was refused, copy them again from Nord Account > NordVPN > Manual setup.';
+}
 export class VpnLogin {
     storageRoot;
     secrets;
@@ -36,13 +50,13 @@ export class VpnLogin {
     }
     /** Encrypts and saves the login (replacing an earlier one). */
     save(provider, login) {
-        const problem = loginProblem(login);
+        const problem = loginProblem({ username: login.username.trim(), password: login.password.trim() }, provider);
         if (problem)
             fail(problem, 'Type the service credentials again.');
         this.file(provider).write({
             provider,
             savedAt: new Date().toISOString(),
-            sealed: this.secrets.sealJson({ username: login.username.trim(), password: login.password }),
+            sealed: this.secrets.sealJson({ username: login.username.trim(), password: login.password.trim() }),
         });
     }
     /** The login, decrypted. Only the launch calls this. */

package/dist/host/vpn/nordvpn.d.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
-/** Reads a URL as text, refusing more than `max` bytes (a server cannot make this PC download without end). */
-export type Fetcher = (url: string, max: number) => Promise<string>;
-export declare function fetchBounded(url: string, max: number): Promise<string>;
+import { fetchBounded, type Fetcher } from '../../shared/download/index.js';
+export { fetchBounded, type Fetcher };
 declare const CountriesSchema: z.ZodArray<z.ZodObject<{
     id: z.ZodNumber;
     name: z.ZodString;
@@ -18,4 +17,3 @@ export declare function findCountry(countries: z.output<typeof CountriesSchema>,
 export declare function recommendedServer(protocol: 'udp' | 'tcp', country: string, fetchText?: Fetcher): Promise<NordServer>;
 /** The server's OpenVPN profile (not yet checked: shared/vpn/ovpn.ts does that). */
 export declare function nordProfile(server: NordServer, protocol: 'udp' | 'tcp', fetchText?: Fetcher): Promise<string>;
-export {};

package/dist/host/vpn/nordvpn.js

@@ -3,35 +3,13 @@
 // is checked here (bounded size, strict shapes, shared/vpn/ovpn.ts) before the sandbox gets it. Nothing here needs
 // the login: the profiles are public.
 import { z } from 'zod';
-import { fetchRetry } from '../../shared/download/index.js';
+import { fetchBounded } from '../../shared/download/index.js';
 import { fail } from '../../core/util/index.js';
 import { MAX_OVPN_BYTES } from '../../shared/vpn/ovpn.js';
 const API = 'https://api.nordvpn.com/v1';
 const CONFIGS = 'https://downloads.nordcdn.com/configs/files';
 const MAX_JSON_BYTES = 2 * 1024 * 1024;
-export async function fetchBounded(url, max) {
-    const response = await fetchRetry(url, {}, 2, 30000);
-    const length = Number(response.headers.get('content-length')) || 0;
-    if (length > max)
-        throw new Error('The answer from ' + new URL(url).host + ' is too big.');
-    const reader = response.body?.getReader();
-    if (!reader)
-        throw new Error('Empty answer from ' + new URL(url).host + '.');
-    const chunks = [];
-    let size = 0;
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        size += value.length;
-        if (size > max) {
-            await reader.cancel();
-            throw new Error('The answer from ' + new URL(url).host + ' is too big.');
-        }
-        chunks.push(value);
-    }
-    return Buffer.concat(chunks).toString('utf8');
-}
+export { fetchBounded };
 const CountriesSchema = z
     .array(z.object({ id: z.number().int(), name: z.string().max(100), code: z.string().max(4) }))
     .max(400);