@phpsandbox/sdk 0.1.13 → 0.1.14

package/examples/notebook-readonly-smoke.ts

@@ -1,806 +0,0 @@
-import fs from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import https from 'node:https';
-import axios from 'axios';
-import NodeWebSocket from 'ws';
-import {
-  NotebookInstance,
-  PHPSandbox,
-  type NotebookData,
-  type NotebookInitProgress,
-  type NotebookInitResult,
-  type PortInfo,
-} from '@phpsandbox/sdk';
-
-const DEFAULT_API_URL = 'https://api.phpsandbox.io/v1';
-const DEFAULT_LOCAL_API_URL = 'https://api.phpsandbox.test/v1';
-
-interface ParsedArgs {
-  get(key: string): string | boolean | undefined;
-}
-
-interface SmokeOptions {
-  token: string;
-  local: boolean;
-  apiUrl: string;
-  notebookId: string;
-  runtimeUrl?: string;
-  runtimeOrigin?: string;
-  includeExec: boolean;
-  includeDownload: boolean;
-  includePreview: boolean;
-  debug: boolean;
-  insecureTls: boolean;
-  caFile?: string;
-  stepTimeoutMs: number;
-  streamTimeoutMs: number;
-  maxStreamChars: number;
-  json: boolean;
-  jsonFile?: string;
-}
-
-interface StepArtifact {
-  name: string;
-  status: 'passed' | 'failed' | 'skipped';
-  durationMs: number;
-  detail?: string;
-  error?: string;
-}
-
-interface InitTraceArtifact {
-  resultType?: NotebookInitResult['type'];
-  events: Array<{
-    atMs: number;
-    kind?: string;
-    step?: string;
-    message: string;
-    details?: string;
-    durationMs?: number;
-  }>;
-}
-
-interface SmokeArtifact {
-  status: 'passed' | 'failed';
-  durationMs: number;
-  options: {
-    apiUrl: string;
-    local: boolean;
-    notebookId: string;
-    runtimeUrl?: string;
-    runtimeOrigin?: string;
-    includeExec: boolean;
-    includeDownload: boolean;
-    includePreview: boolean;
-  };
-  notebook?: {
-    id: string;
-    title?: string;
-    type?: string;
-    runtimeUrl: string;
-  };
-  initTrace: InitTraceArtifact;
-  steps: StepArtifact[];
-}
-
-async function main(): Promise<void> {
-  const startedAt = performance.now();
-  const options = parseOptions(process.argv.slice(2));
-  const steps: StepArtifact[] = [];
-  const initTrace: InitTraceArtifact = { events: [] };
-  const transport = await createNodeTransport(options);
-  const client = PHPSandbox.realtime(options.token, options.apiUrl, {
-    debug: options.debug,
-    ...transport,
-  });
-
-  let notebook: NotebookInstance | null = null;
-  let notebookData: NotebookData | null = null;
-
-  try {
-    const response = await recordStep(steps, 'api.get-notebook', options.stepTimeoutMs, async () => {
-      const result = await client.notebook.get(options.notebookId);
-      result.dispose();
-      return {
-        data: result.data,
-        detail: `id=${result.data.id} type=${result.data.type ?? ''} title=${result.data.title ?? ''} runtimeUrl=${redactUrl(result.data.runtimeUrl)}`,
-      };
-    });
-
-    notebookData = {
-      ...response.data,
-      runtimeUrl: resolveRuntimeUrl(response.data.runtimeUrl, options),
-    };
-
-    notebook = client.notebook.open(notebookData);
-    const initStartedAt = performance.now();
-    notebook.listen('init.event', (event: NotebookInitProgress) => {
-      initTrace.events.push({
-        atMs: performance.now() - initStartedAt,
-        kind: event.kind,
-        step: event.step,
-        message: event.message,
-        details: event.details,
-      });
-    });
-    notebook.onDidInitialize((result) => {
-      initTrace.resultType = result.type;
-    });
-
-    const readyStep = await recordStep(steps, 'notebook.ready', options.stepTimeoutMs, async () => {
-      const result = await notebook!.ready();
-      assertValidUrl(result.data.previewUrl, 'notebook.ready previewUrl');
-      const ports = assertPortInfoList(result.data.ports, 'notebook.ready ports');
-      return {
-        result,
-        detail: `type=${result.type} env=${result.data.env.length} ${describePorts(ports)} previewUrl=${redactUrl(result.data.previewUrl)}`,
-      };
-    });
-    const ready = readyStep.result;
-
-    await recordStep(steps, 'container.opened-ports', options.stepTimeoutMs, async () => {
-      const ports = await notebook!.runtime.ports.list();
-      return describePorts(assertPortInfoList(ports, 'ports.list'));
-    }, false);
-
-    const rootSnapshot = await recordStep(steps, 'filesystem.root', options.stepTimeoutMs, async () => {
-      const rootEntries = await notebook!.files.list('/');
-
-      const preferred = ['composer.json', 'index.php', 'artisan'];
-      const rootNames = new Set(rootEntries.map(([name]) => name));
-      const candidate = preferred.find((name) => rootNames.has(name));
-      return {
-        detail: `rootEntries=${rootEntries.length}`,
-        candidate,
-      };
-    });
-
-    const treePath = rootSnapshot.candidate === 'artisan' ? 'routes' : undefined;
-    if (treePath) {
-      await recordStep(steps, 'filesystem.tree', options.stepTimeoutMs, async () => {
-        const tree = await notebook!.files.tree(treePath);
-        return `path=${treePath} bytes=${tree.length}`;
-      }, false);
-    } else {
-      recordSkippedStep(steps, 'filesystem.tree', 'No small known directory selected for tree.');
-    }
-
-    const findSnapshot = await recordStep(steps, 'filesystem.find', options.stepTimeoutMs, async () => {
-      const [composerFiles, indexFiles] = await Promise.all([
-        notebook!.files.find('composer.json', { maxResults: 10 }),
-        notebook!.files.find('index.php', { maxResults: 10 }),
-      ]);
-      const candidate = [...composerFiles, ...indexFiles]
-        .find((file) => typeof file.path === 'string')
-        ?.path;
-      return {
-        detail: `composerFiles=${composerFiles.length} indexFiles=${indexFiles.length}`,
-        candidate,
-      };
-    }, false);
-
-    const candidate = findSnapshot?.candidate ?? rootSnapshot.candidate;
-
-    if (candidate) {
-      await recordStep(steps, 'filesystem.read-candidate', options.stepTimeoutMs, async () => {
-        const [stat, content, tail] = await Promise.all([
-          notebook!.files.stat(candidate),
-          notebook!.files.read(candidate),
-          notebook!.files.tail(candidate, { lines: 10 }),
-        ]);
-
-        return `path=${candidate} size=${stat.size} sha256=${sha256(content)} tailBytes=${tail.length}`;
-      }, false);
-    } else {
-      recordSkippedStep(steps, 'filesystem.read-candidate', 'No readable candidate file found.');
-    }
-
-    if (options.includeDownload) {
-      if (candidate) {
-        await recordStep(steps, 'filesystem.download', options.stepTimeoutMs, async () => {
-          const archive = await notebook!.files.download({
-            exclude: ['vendor/**', 'node_modules/**'],
-            include: [candidate],
-          });
-          if (archive.size === 0) {
-            throw new Error('file.download() returned an empty blob.');
-          }
-          return `${archive.size} bytes`;
-        }, false);
-      } else {
-        recordSkippedStep(steps, 'filesystem.download', 'No readable candidate file found.');
-      }
-    } else {
-      recordSkippedStep(steps, 'filesystem.download', 'Enable with --include-download.');
-    }
-
-    await recordStep(steps, 'filesystem.search', options.stepTimeoutMs, async () => {
-      const [hasMore, matches] = await notebook!.files.search({
-        pattern: 'php',
-        isRegExp: false,
-        isCaseSensitive: false,
-      });
-      return `matches=${matches.length} hasMore=${hasMore}`;
-    }, false);
-
-    await recordStep(steps, 'git.status', options.stepTimeoutMs, async () => {
-      const status = await notebook!.git.status();
-      return `initialized=${status.initialized} clean=${status.clean} branch=${status.branch}`;
-    }, false);
-
-    await recordStep(steps, 'git.log', options.stepTimeoutMs, async () => {
-      const log = await notebook!.git.log('main');
-      return `commits=${log.length}`;
-    }, false);
-
-    await recordStep(steps, 'service.list', options.stepTimeoutMs, async () => {
-      const services = await notebook!.services.list();
-      return `services=${services.length}`;
-    }, false);
-
-    await recordStep(steps, 'composer.packages', options.stepTimeoutMs, async () => {
-      const packages = await notebook!.composer.packages();
-      return `packages=${packages.length}`;
-    }, false);
-
-    if (options.includeExec) {
-      await runExecutionChecks(notebook, steps, options);
-    } else {
-      recordSkippedStep(steps, 'shell.run', 'Enable with --include-exec.');
-      recordSkippedStep(steps, 'terminals.create', 'Enable with --include-exec.');
-      recordSkippedStep(steps, 'terminal.interactive', 'Enable with --include-exec.');
-      recordSkippedStep(steps, 'terminal.osc', 'Enable with --include-exec.');
-      recordSkippedStep(steps, 'repl.eval', 'Enable with --include-exec.');
-    }
-
-    if (options.includePreview) {
-      await recordStep(steps, 'preview.fetch', options.stepTimeoutMs, async () => {
-        const response = await fetch(ready.data.previewUrl, {
-          redirect: 'manual',
-          signal: AbortSignal.timeout(options.stepTimeoutMs),
-        });
-        return `status=${response.status} url=${redactUrl(ready.data.previewUrl)}`;
-      }, false);
-    } else {
-      recordSkippedStep(steps, 'preview.fetch', 'Enable with --include-preview.');
-    }
-  } finally {
-    notebook?.dispose();
-  }
-
-  const status = steps.some((step) => step.status === 'failed') ? 'failed' : 'passed';
-  const artifact: SmokeArtifact = {
-    status,
-    durationMs: performance.now() - startedAt,
-    options: {
-      apiUrl: options.apiUrl,
-      local: options.local,
-      notebookId: options.notebookId,
-      runtimeUrl: options.runtimeUrl ? redactUrl(options.runtimeUrl) : undefined,
-      runtimeOrigin: options.runtimeOrigin,
-      includeExec: options.includeExec,
-      includeDownload: options.includeDownload,
-      includePreview: options.includePreview,
-    },
-    notebook: notebookData
-      ? {
-          id: notebookData.id,
-          title: notebookData.title,
-          type: notebookData.type,
-          runtimeUrl: redactUrl(notebookData.runtimeUrl),
-        }
-      : undefined,
-    initTrace,
-    steps,
-  };
-
-  if (options.jsonFile) {
-    await fs.writeFile(options.jsonFile, `${JSON.stringify(artifact, null, 2)}\n`, 'utf8');
-  }
-
-  if (options.json) {
-    console.log(JSON.stringify(artifact, null, 2));
-  } else {
-    printSummary(artifact);
-  }
-
-  if (status === 'failed') {
-    process.exitCode = 1;
-  }
-}
-
-async function runExecutionChecks(notebook: NotebookInstance, steps: StepArtifact[], options: SmokeOptions): Promise<void> {
-  await recordStep(steps, 'shell.run', options.stepTimeoutMs, async () => {
-    const result = await notebook.run(['php', '-r', 'echo "sdk-smoke";']).wait();
-    if (result.exitCode !== 0) {
-      throw new Error(result.stderr || result.output);
-    }
-    if (!result.output.includes('sdk-smoke')) {
-      throw new Error(`Unexpected shell output: ${result.output}`);
-    }
-    return `exit=${result.exitCode}`;
-  }, false);
-
-  await recordStep(steps, 'terminals.create', options.stepTimeoutMs, async () => {
-    const process = await notebook.terminals.create({ command: 'php', args: ['-r', 'echo "sdk-smoke";'] });
-    const [exitCode, output] = await Promise.all([
-      withTimeout(process.wait(), options.stepTimeoutMs, 'waiting for terminal process exit'),
-      readStreamToString(process.output, options.streamTimeoutMs, options.maxStreamChars),
-    ]);
-
-    if (exitCode !== 0 || !output.includes('sdk-smoke')) {
-      throw new Error(`terminals.create failed: exit=${exitCode} output=${trimDetail(output)}`);
-    }
-
-    return `exit=${exitCode}`;
-  }, false);
-
-  await recordStep(steps, 'terminal.interactive', options.stepTimeoutMs, async () => {
-    const process = await notebook.terminals.create({
-      command: 'bash',
-      args: ['-lc', 'IFS= read -r line; printf "sdk-input:%s\\n" "$line"'],
-    });
-
-    try {
-      const writer = process.input.getWriter();
-      await writer.write('hello-from-sdk\n');
-      writer.releaseLock();
-
-      const [exitCode, output] = await Promise.all([
-        withTimeout(process.wait(), options.stepTimeoutMs, 'waiting for interactive terminal process exit'),
-        readStreamToString(process.output, options.streamTimeoutMs, options.maxStreamChars),
-      ]);
-
-      if (exitCode !== 0 || !output.includes('sdk-input:hello-from-sdk')) {
-        throw new Error(`terminal.interactive failed: exit=${exitCode} output=${trimDetail(output)}`);
-      }
-
-      return `exit=${exitCode}`;
-    } finally {
-      await process.kill().catch(() => false);
-    }
-  }, false);
-
-  await recordStep(steps, 'terminal.osc', options.stepTimeoutMs, async () => {
-    const process = await notebook.terminals.create({
-      command: 'bash',
-      args: ['-lc', 'printf "sdk-prompt$"'],
-      osc: true,
-      size: [80, 15],
-    });
-
-    try {
-      const [exitCode, output] = await Promise.all([
-        withTimeout(process.wait(), options.stepTimeoutMs, 'waiting for terminal OSC process exit'),
-        readStreamToString(process.output, options.streamTimeoutMs, options.maxStreamChars),
-      ]);
-
-      if (exitCode !== 0 || !output.includes('\x1b]654;interactive\x07') || !output.includes('\x1b]654;prompt\x07')) {
-        throw new Error(`terminal.osc failed: exit=${exitCode} output=${trimDetail(output)}`);
-      }
-
-      return `exit=${exitCode}`;
-    } finally {
-      await process.kill().catch(() => false);
-    }
-  }, false);
-
-  await recordStep(steps, 'repl.eval', options.stepTimeoutMs, async () => {
-    const result = await notebook.repl.eval('return "sdk-smoke";');
-    if (result.exitCode !== 0) {
-      throw new Error(`repl.eval exited with ${result.exitCode}`);
-    }
-    return `exit=${result.exitCode}`;
-  }, false);
-}
-
-async function recordStep<T>(
-  steps: StepArtifact[],
-  name: string,
-  timeoutMs: number,
-  action: () => Promise<T>,
-  required = true
-): Promise<T> {
-  const startedAt = performance.now();
-
-  try {
-    const value = await withTimeout(action(), timeoutMs, `${name} timed out after ${timeoutMs}ms`);
-    steps.push({
-      name,
-      status: 'passed',
-      durationMs: performance.now() - startedAt,
-      detail: describeValue(value),
-    });
-    console.log(`PASS ${name} ${formatDuration(performance.now() - startedAt)}`);
-    return value;
-  } catch (error) {
-    steps.push({
-      name,
-      status: 'failed',
-      durationMs: performance.now() - startedAt,
-      error: formatError(error),
-    });
-    console.log(`FAIL ${name} ${formatDuration(performance.now() - startedAt)} ${formatError(error)}`);
-    if (required) {
-      throw error;
-    }
-    return undefined as T;
-  }
-}
-
-function recordSkippedStep(steps: StepArtifact[], name: string, detail: string): void {
-  steps.push({
-    name,
-    status: 'skipped',
-    durationMs: 0,
-    detail,
-  });
-  console.log(`SKIP ${name} ${detail}`);
-}
-
-async function readStreamToString(stream: ReadableStream<string | Uint8Array>, timeoutMs: number, maxChars: number): Promise<string> {
-  const reader = stream.getReader();
-  let output = '';
-
-  try {
-    while (output.length < maxChars) {
-      const chunk = await withTimeout(reader.read(), timeoutMs, 'waiting for stream output');
-      if (chunk.done) {
-        break;
-      }
-      output += chunk.value instanceof Uint8Array ? new TextDecoder().decode(chunk.value) : (chunk.value ?? '');
-    }
-    return output;
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-function resolveRuntimeUrl(original: string, options: SmokeOptions): string {
-  if (options.runtimeUrl) {
-    return options.runtimeUrl;
-  }
-
-  if (!options.runtimeOrigin) {
-    return original;
-  }
-
-  const source = new URL(original);
-  const target = new URL(options.runtimeOrigin);
-  source.protocol = target.protocol;
-  source.host = target.host;
-  return source.toString();
-}
-
-function parseOptions(argv: string[]): SmokeOptions {
-  const args = parseArgs(argv);
-
-  if (booleanArg(args, 'help') === true) {
-    printHelp();
-    process.exit(0);
-  }
-
-  const token = stringArg(args, 'token') ?? process.env.PHPSANDBOX_TOKEN;
-  if (!token) {
-    throw new Error('Missing PHPSANDBOX_TOKEN. Pass it via the environment or --token.');
-  }
-
-  return {
-    token,
-    local: booleanArg(args, 'local') ?? false,
-    apiUrl:
-      stringArg(args, 'api-url') ??
-      process.env.PHPSANDBOX_API_URL ??
-      ((booleanArg(args, 'local') ?? false) ? DEFAULT_LOCAL_API_URL : DEFAULT_API_URL),
-    notebookId: stringArg(args, 'notebook-id') ?? 'gypjc',
-    runtimeUrl: stringArg(args, 'runtime-url'),
-    runtimeOrigin: stringArg(args, 'runtime-origin'),
-    includeExec: booleanArg(args, 'include-exec') ?? false,
-    includeDownload: booleanArg(args, 'include-download') ?? false,
-    includePreview: booleanArg(args, 'include-preview') ?? false,
-    debug: booleanArg(args, 'debug') ?? false,
-    insecureTls: booleanArg(args, 'insecure-tls') ?? ((booleanArg(args, 'local') ?? false) && !stringArg(args, 'ca-file')),
-    caFile: stringArg(args, 'ca-file'),
-    stepTimeoutMs: numberArg(args, 'step-timeout-ms') ?? 60_000,
-    streamTimeoutMs: numberArg(args, 'stream-timeout-ms') ?? 20_000,
-    maxStreamChars: numberArg(args, 'max-stream-chars') ?? 100_000,
-    json: booleanArg(args, 'json') ?? false,
-    jsonFile: stringArg(args, 'json-file'),
-  };
-}
-
-async function createNodeTransport(options: SmokeOptions): Promise<{
-  fetch?: typeof globalThis.fetch;
-  webSocket?: typeof NodeWebSocket;
-}> {
-  if (!options.insecureTls && !options.caFile) {
-    return {};
-  }
-
-  if (!options.apiUrl.startsWith('https://')) {
-    return {};
-  }
-
-  const ca = options.caFile ? await fs.readFile(options.caFile, 'utf8') : undefined;
-  const agentOptions = {
-    ca,
-    rejectUnauthorized: !options.insecureTls,
-  };
-  const httpsAgent = new https.Agent(agentOptions);
-
-  class ConfiguredWebSocket extends NodeWebSocket {
-    public constructor(address: string | URL, protocols?: string | string[]) {
-      super(address, protocols, agentOptions);
-    }
-  }
-
-  const fetch: typeof globalThis.fetch = async (input, init) => {
-    const request = input instanceof Request ? input : new Request(input, init);
-    const headers: Record<string, string> = {};
-    request.headers.forEach((value, key) => {
-      headers[key] = value;
-    });
-    const body =
-      request.method === 'GET' || request.method === 'HEAD'
-        ? undefined
-        : Buffer.from(await request.arrayBuffer());
-
-    const response = await axios.request<ArrayBuffer>({
-      url: request.url,
-      method: request.method as any,
-      headers,
-      data: body,
-      responseType: 'arraybuffer',
-      validateStatus: () => true,
-      httpsAgent,
-    });
-
-    const responseHeaders = new Headers();
-    for (const [key, value] of Object.entries(response.headers)) {
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          responseHeaders.append(key, String(item));
-        }
-      } else if (value !== undefined) {
-        responseHeaders.set(key, String(value));
-      }
-    }
-
-    return new Response(response.data, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: responseHeaders,
-    });
-  };
-
-  return { fetch, webSocket: ConfiguredWebSocket as typeof NodeWebSocket };
-}
-
-function parseArgs(argv: string[]): ParsedArgs {
-  const values = new Map<string, string | boolean>();
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const current = argv[index];
-    if (!current.startsWith('--')) {
-      continue;
-    }
-
-    if (current.startsWith('--no-')) {
-      values.set(current.slice(5), false);
-      continue;
-    }
-
-    const assignment = current.match(/^--([^=]+)=(.*)$/);
-    if (assignment) {
-      values.set(assignment[1], assignment[2]);
-      continue;
-    }
-
-    const key = current.slice(2);
-    const next = argv[index + 1];
-    if (next && !next.startsWith('--')) {
-      values.set(key, next);
-      index += 1;
-      continue;
-    }
-
-    values.set(key, true);
-  }
-
-  return {
-    get(key: string) {
-      return values.get(key);
-    },
-  };
-}
-
-function stringArg(args: ParsedArgs, key: string): string | undefined {
-  const value = args.get(key);
-  return typeof value === 'string' && value !== '' ? value : undefined;
-}
-
-function numberArg(args: ParsedArgs, key: string): number | undefined {
-  const value = stringArg(args, key);
-  if (value === undefined) {
-    return undefined;
-  }
-
-  const number = Number(value);
-  if (!Number.isFinite(number)) {
-    throw new Error(`Invalid --${key}: ${value}`);
-  }
-
-  return number;
-}
-
-function booleanArg(args: ParsedArgs, key: string): boolean | undefined {
-  const value = args.get(key);
-  if (typeof value === 'boolean') {
-    return value;
-  }
-  if (value === undefined) {
-    return undefined;
-  }
-  if (value === 'true' || value === '1') {
-    return true;
-  }
-  if (value === 'false' || value === '0') {
-    return false;
-  }
-  throw new Error(`Invalid --${key}: ${value}`);
-}
-
-function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(label)), timeoutMs);
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve(value);
-      },
-      (error) => {
-        clearTimeout(timer);
-        reject(error);
-      }
-    );
-  });
-}
-
-function sha256(value: Uint8Array): string {
-  return createHash('sha256').update(value).digest('hex');
-}
-
-function assertValidUrl(value: unknown, label: string): string {
-  if (typeof value !== 'string' || value.length === 0) {
-    throw new Error(`${label} must be a non-empty string, got ${JSON.stringify(value)}`);
-  }
-
-  try {
-    new URL(value);
-  } catch {
-    throw new Error(`${label} must be a valid URL, got ${JSON.stringify(value)}`);
-  }
-
-  return value;
-}
-
-function assertPortInfoList(value: unknown, label: string): PortInfo[] {
-  if (!Array.isArray(value)) {
-    throw new Error(`${label} must be an array, got ${JSON.stringify(value)}`);
-  }
-
-  value.forEach((rawPort, index) => {
-    if (!rawPort || typeof rawPort !== 'object') {
-      throw new Error(`${label}[${index}] must be an object, got ${JSON.stringify(rawPort)}`);
-    }
-
-    const port = rawPort as Partial<PortInfo>;
-    if (!Number.isInteger(port.port) || (port.port ?? 0) <= 0) {
-      throw new Error(`${label}[${index}].port must be a positive integer, got ${JSON.stringify(port.port)}`);
-    }
-    assertValidUrl(port.url, `${label}[${index}].url`);
-    if (typeof port.subdomain !== 'string' || port.subdomain.length === 0) {
-      throw new Error(`${label}[${index}].subdomain must be a non-empty string, got ${JSON.stringify(port.subdomain)}`);
-    }
-    if (typeof port.default !== 'boolean') {
-      throw new Error(`${label}[${index}].default must be boolean, got ${JSON.stringify(port.default)}`);
-    }
-  });
-
-  return value as PortInfo[];
-}
-
-function describePorts(ports: readonly PortInfo[]): string {
-  const defaultPorts = ports.filter((port) => port.default).map((port) => port.port);
-  return `ports=${ports.length} defaultPorts=${defaultPorts.length > 0 ? defaultPorts.join(',') : 'none'}`;
-}
-
-function redactUrl(value: string): string {
-  try {
-    const url = new URL(value);
-    if (url.search) {
-      url.search = '?redacted=1';
-    }
-    return url.toString();
-  } catch {
-    return '<invalid-url>';
-  }
-}
-
-function describeValue(value: unknown): string {
-  if (value && typeof value === 'object' && 'detail' in value && typeof value.detail === 'string') {
-    return trimDetail(value.detail);
-  }
-  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-    return trimDetail(String(value));
-  }
-  if (value === null || value === undefined) {
-    return String(value);
-  }
-  return trimDetail(JSON.stringify(value));
-}
-
-function trimDetail(value: string, maxLength = 180): string {
-  const normalized = value.replace(/\s+/g, ' ').trim();
-  if (normalized.length <= maxLength) {
-    return normalized;
-  }
-  return `${normalized.slice(0, maxLength - 3)}...`;
-}
-
-function formatError(error: unknown): string {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-
-function formatDuration(durationMs: number): string {
-  if (durationMs < 1000) {
-    return `${durationMs.toFixed(0)}ms`;
-  }
-  return `${(durationMs / 1000).toFixed(2)}s`;
-}
-
-function printSummary(artifact: SmokeArtifact): void {
-  const passed = artifact.steps.filter((step) => step.status === 'passed').length;
-  const failed = artifact.steps.filter((step) => step.status === 'failed').length;
-  const skipped = artifact.steps.filter((step) => step.status === 'skipped').length;
-
-  console.log('\n=== Notebook readonly smoke summary ===');
-  console.log(`Status: ${artifact.status}`);
-  console.log(`Notebook: ${artifact.options.notebookId}`);
-  console.log(`Runtime URL: ${artifact.notebook?.runtimeUrl ?? 'unresolved'}`);
-  console.log(`Duration: ${formatDuration(artifact.durationMs)}`);
-  console.log(`Steps: passed=${passed} failed=${failed} skipped=${skipped}`);
-
-  for (const step of artifact.steps) {
-    const detail = step.error ?? step.detail ?? '';
-    console.log(`  ${step.status.padEnd(7)} ${step.name.padEnd(28)} ${formatDuration(step.durationMs).padStart(8)} ${detail}`);
-  }
-}
-
-function printHelp(): void {
-  console.log(`Usage:
-  PHPSANDBOX_TOKEN=... npx tsx examples/notebook-readonly-smoke.ts [options]
-
-Options:
-  --notebook-id=<id>        Existing notebook id to open. Defaults to gypjc.
-  --api-url=<url>           PHPSandbox API URL. Defaults to ${DEFAULT_API_URL}.
-  --local                   Use ${DEFAULT_LOCAL_API_URL} and default to insecure TLS.
-  --insecure-tls            Disable TLS verification for local HTTPS/WSS.
-  --ca-file=<path>          Trust a custom CA for local HTTPS/WSS.
-  --runtime-url=<url>       Replace the notebook runtimeUrl with a full WebSocket URL.
-  --runtime-origin=<origin> Replace only the runtimeUrl origin, preserving path/query auth.
-  --include-exec            Also run shell, terminal, and REPL read-safe execution checks.
-  --include-download        Also run a read-only file.download() check for a known file.
-  --include-preview         Fetch the initialized preview URL.
-  --json                    Print the full JSON artifact.
-  --json-file=<path>        Write the JSON artifact to a file.
-  --step-timeout-ms=<ms>    Per-step timeout. Defaults to 60000.
-`);
-}
-
-void main().catch((error) => {
-  console.error(formatError(error));
-  process.exitCode = 1;
-});