@notis_ai/cli 0.2.0-beta.102.1

package/src/runtime/store-screenshot.js

@@ -0,0 +1,138 @@
+import sharp from 'sharp';
+import { fileURLToPath } from 'node:url';
+
+const STORE_SCREENSHOT_ASPECT = 16 / 10;
+const SHARED_BACKDROP_PATH = fileURLToPath(
+  new URL('./assets/store-screenshot-dark.png', import.meta.url),
+);
+
+const ACCENT_PALETTES = {
+  blue: { glow: '#4f7cff', glow2: '#274690' },
+  violet: { glow: '#9b87f5', glow2: '#5038a1' },
+  emerald: { glow: '#34d399', glow2: '#176b55' },
+  amber: { glow: '#f2a94a', glow2: '#8b4f20' },
+  rose: { glow: '#fb7185', glow2: '#8f3048' },
+  sky: { glow: '#38bdf8', glow2: '#176887' },
+  fuchsia: { glow: '#d946ef', glow2: '#772786' },
+  teal: { glow: '#2dd4bf', glow2: '#176e68' },
+};
+
+const ACCENT_NAMES = Object.keys(ACCENT_PALETTES);
+
+function stableHash(value) {
+  let hash = 2166136261;
+  for (const character of String(value || 'notis-app')) {
+    hash ^= character.codePointAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+export function resolveStoreScreenshotAccent(accent, seed = 'notis-app') {
+  if (accent && ACCENT_PALETTES[accent]) {
+    return accent;
+  }
+  return ACCENT_NAMES[stableHash(seed) % ACCENT_NAMES.length];
+}
+
+export function storeScreenshotLayout(width = 2000, height = 1250) {
+  const horizontalInset = Math.max(48, Math.round(width * 0.06));
+  const verticalInset = Math.max(40, Math.round(height * 0.06));
+  let cardWidth = width - horizontalInset * 2;
+  let cardHeight = Math.round(cardWidth / STORE_SCREENSHOT_ASPECT);
+  const maximumCardHeight = height - verticalInset * 2;
+  if (cardHeight > maximumCardHeight) {
+    cardHeight = maximumCardHeight;
+    cardWidth = Math.round(cardHeight * STORE_SCREENSHOT_ASPECT);
+  }
+  const cardLeft = Math.round((width - cardWidth) / 2);
+  const cardTop = Math.round((height - cardHeight) / 2) - Math.round(height * 0.008);
+  return {
+    width,
+    height,
+    cardWidth,
+    cardHeight,
+    cardLeft,
+    cardTop,
+    radius: Math.max(18, Math.round(width * 0.016)),
+  };
+}
+
+async function backdropImage(layout) {
+  return sharp(SHARED_BACKDROP_PATH)
+    .resize(layout.width, layout.height, { fit: 'cover', position: 'centre' })
+    .png()
+    .toBuffer();
+}
+
+function roundedRectSvg(width, height, radius, { fill = '#ffffff', stroke = null } = {}) {
+  const strokeAttribute = stroke
+    ? ` fill="none" stroke="${stroke}" stroke-width="2"`
+    : ` fill="${fill}"`;
+  return Buffer.from(
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}"><rect x="1" y="1" width="${width - 2}" height="${height - 2}" rx="${radius}" ry="${radius}"${strokeAttribute}/></svg>`,
+  );
+}
+
+/**
+ * Composite a truthful browser capture into the deterministic Store frame.
+ * The source pixels are only resized/cropped; the app UI is never redrawn.
+ */
+export async function composeStoreScreenshot({
+  inputPath,
+  outputPath,
+  width = 2000,
+  height = 1250,
+  accent = null,
+  seed = 'notis-app',
+  focused = false,
+  theme = 'light',
+}) {
+  const resolvedTheme = theme === 'dark' ? 'dark' : 'light';
+  const layout = storeScreenshotLayout(width, height);
+  const resolvedAccent = resolveStoreScreenshotAccent(accent, seed);
+
+  const roundedCapture = await sharp(inputPath)
+    .resize(layout.cardWidth, layout.cardHeight, {
+      fit: 'cover',
+      position: focused ? 'top' : 'centre',
+    })
+    .composite([{
+      input: roundedRectSvg(layout.cardWidth, layout.cardHeight, layout.radius),
+      blend: 'dest-in',
+    }])
+    .png()
+    .toBuffer();
+
+  const border = roundedRectSvg(
+    layout.cardWidth,
+    layout.cardHeight,
+    layout.radius,
+    { stroke: resolvedTheme === 'dark' ? '#FFFFFF2A' : '#0F172A22' },
+  );
+
+  await sharp(await backdropImage(layout))
+    .composite([
+      { input: roundedCapture, left: layout.cardLeft, top: layout.cardTop },
+      { input: border, left: layout.cardLeft, top: layout.cardTop },
+    ])
+    .png({
+      compressionLevel: 9,
+      adaptiveFiltering: true,
+    })
+    .toFile(outputPath);
+
+  return {
+    mode: 'framed',
+    accent: resolvedAccent,
+    focused: Boolean(focused),
+    theme: resolvedTheme,
+    card: {
+      left: layout.cardLeft,
+      top: layout.cardTop,
+      width: layout.cardWidth,
+      height: layout.cardHeight,
+      radius: layout.radius,
+    },
+  };
+}

package/src/runtime/transport.js

@@ -0,0 +1,347 @@
+import { randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { CliError, EXIT_CODES } from './errors.js';
+import {
+  DEFAULT_PROFILE,
+  getProfile,
+  isJwtExpired,
+  loadConfig,
+} from './profiles.js';
+import { createExpiredAuthError, createInvalidAuthHints } from './desktop-auth.js';
+
+function escapeMultipartHeaderValue(value) {
+  return String(value ?? '')
+    .replace(/"/g, '%22')
+    .replace(/\r/g, '%0D')
+    .replace(/\n/g, '%0A');
+}
+
+function multipartTextPart(boundary, name, value) {
+  return [
+    `--${boundary}`,
+    `Content-Disposition: form-data; name="${escapeMultipartHeaderValue(name)}"`,
+    '',
+    value,
+    '',
+  ].join('\r\n');
+}
+
+function multipartFileHeader(boundary, binding) {
+  const filename = escapeMultipartHeaderValue(binding.basename || binding.field_name);
+  return [
+    `--${boundary}`,
+    `Content-Disposition: form-data; name="${escapeMultipartHeaderValue(binding.field_name)}"; filename="${filename}"`,
+    `Content-Type: ${binding.contentType || 'application/octet-stream'}`,
+    '',
+    '',
+  ].join('\r\n');
+}
+
+async function* multipartFileBody(boundary, payload, bindingMetadata, fileBindings) {
+  yield Buffer.from(multipartTextPart(boundary, 'payload', JSON.stringify(payload)));
+  yield Buffer.from(multipartTextPart(boundary, 'file_bindings', JSON.stringify(bindingMetadata)));
+  for (const binding of fileBindings) {
+    yield Buffer.from(multipartFileHeader(boundary, binding));
+    for await (const chunk of createReadStream(binding.localPath)) {
+      yield chunk;
+    }
+    yield Buffer.from('\r\n');
+  }
+  yield Buffer.from(`--${boundary}--\r\n`);
+}
+
+function createMultipartFileUpload(payload, bindingMetadata, fileBindings) {
+  const boundary = `----notis-cli-${randomUUID().replace(/-/g, '')}`;
+  const textParts = [
+    multipartTextPart(boundary, 'payload', JSON.stringify(payload)),
+    multipartTextPart(boundary, 'file_bindings', JSON.stringify(bindingMetadata)),
+  ];
+  const fileHeaderParts = fileBindings.map((binding) => multipartFileHeader(boundary, binding));
+  const closingPart = `--${boundary}--\r\n`;
+  const contentLength = [
+    ...textParts,
+    ...fileHeaderParts,
+    ...fileBindings.map(() => '\r\n'),
+    closingPart,
+  ].reduce((total, part) => total + Buffer.byteLength(part), 0)
+    + fileBindings.reduce((total, binding) => total + binding.size, 0);
+
+  return {
+    body: multipartFileBody(boundary, payload, bindingMetadata, fileBindings),
+    headers: {
+      'Content-Type': `multipart/form-data; boundary=${boundary}`,
+      'Content-Length': String(contentLength),
+    },
+    duplex: 'half',
+  };
+}
+
+function normalizeBackendError(status, payload, runtime) {
+  const backendError = payload?.error;
+  const message =
+    backendError?.message ||
+    backendError ||
+    payload?.message ||
+    payload?.error ||
+    `Request failed with status ${status}`;
+
+  if (status === 401) {
+    return new CliError({
+      code: 'auth_invalid',
+      message,
+      exitCode: EXIT_CODES.auth,
+      hints: [
+        ...createInvalidAuthHints(runtime),
+      ],
+      details: payload || {},
+    });
+  }
+
+  if (status === 409) {
+    return new CliError({
+      code: 'conflict',
+      message,
+      exitCode: EXIT_CODES.conflict,
+      retryable: false,
+      hints: payload?.hints || [],
+      details: payload || {},
+    });
+  }
+
+  if (status === 403) {
+    return new CliError({
+      code: 'forbidden',
+      message,
+      exitCode: EXIT_CODES.auth,
+      details: payload || {},
+      hints: [
+        { command: 'notis tools toolkits', reason: 'Check which toolkits are available' },
+        { command: 'notis whoami', reason: 'Verify your active profile and permissions' },
+        ...(payload?.hints || []),
+      ],
+    });
+  }
+
+  if (status >= 400 && status < 500) {
+    return new CliError({
+      code: 'usage_error',
+      message,
+      exitCode: EXIT_CODES.usage,
+      details: payload || {},
+      hints: payload?.hints || [],
+    });
+  }
+
+  return new CliError({
+    code: 'backend_error',
+    message,
+    exitCode: EXIT_CODES.backend,
+    retryable: status >= 500,
+    details: payload || {},
+    hints: payload?.hints || [],
+  });
+}
+
+function reloadJwtFromConfig(runtime) {
+  if (runtime.credentialSource === 'env') {
+    return false;
+  }
+  const profileName = runtime.profileName || DEFAULT_PROFILE;
+  let profile;
+  try {
+    profile = getProfile(loadConfig(), profileName);
+  } catch {
+    return false;
+  }
+  const nextJwt = typeof profile.jwt === 'string' && profile.jwt ? profile.jwt : null;
+  if (!nextJwt || nextJwt === runtime.jwt) {
+    return false;
+  }
+  runtime.jwt = nextJwt;
+  runtime.desktopAppName = profile.desktop_app_name;
+  runtime.desktopPid = profile.desktop_pid;
+  return true;
+}
+
+export async function httpRequest({
+  runtime,
+  method = 'POST',
+  path,
+  body,
+  multipart = false,
+  requireAuth = true,
+}) {
+  // The desktop renderer is the single owner of the rotating Supabase refresh
+  // token. Each CLI request only consumes the newest access token it synced to
+  // disk, avoiding refresh-token races between independent CLI processes and
+  // the running desktop session.
+  reloadJwtFromConfig(runtime);
+  if (requireAuth && isJwtExpired(runtime.jwt)) {
+    throw createExpiredAuthError(runtime);
+  }
+
+  let controller = new AbortController();
+  let timeout = setTimeout(() => controller.abort(), runtime.timeoutMs);
+  const requestId = `req_${randomUUID().replace(/-/g, '')}`;
+  const resetTimeout = () => {
+    clearTimeout(timeout);
+    controller = new AbortController();
+    timeout = setTimeout(() => controller.abort(), runtime.timeoutMs);
+  };
+
+  const headers = {
+    'X-Notis-CLI-Version': runtime.cliVersion,
+    'X-Notis-Request-Id': requestId,
+  };
+  if (!multipart) {
+    headers['Content-Type'] = 'application/json';
+  }
+
+  if (requireAuth && runtime.jwt) {
+    headers.Authorization = `Bearer ${runtime.jwt}`;
+  }
+
+  const resolveBody = () => {
+    if (!multipart) {
+      return {
+        body: body ? JSON.stringify(body) : undefined,
+        headers: {},
+      };
+    }
+    if (typeof body === 'function') {
+      return body();
+    }
+    return {
+      body,
+      headers: {},
+    };
+  };
+
+  try {
+    let requestBody = resolveBody();
+    let response = await fetch(`${runtime.apiBase}${path}`, {
+      method,
+      headers: { ...headers, ...requestBody.headers },
+      body: requestBody.body,
+      signal: controller.signal,
+      ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
+    });
+
+    let payload = null;
+    try {
+      payload = await response.json();
+    } catch {
+      payload = null;
+    }
+
+    if (response.status === 401) {
+      const refreshed = reloadJwtFromConfig(runtime) && !isJwtExpired(runtime.jwt);
+      if (refreshed) {
+        if (requireAuth && runtime.jwt) {
+          headers.Authorization = `Bearer ${runtime.jwt}`;
+        }
+        resetTimeout();
+        requestBody = resolveBody();
+        response = await fetch(`${runtime.apiBase}${path}`, {
+          method,
+          headers: { ...headers, ...requestBody.headers },
+          body: requestBody.body,
+          signal: controller.signal,
+          ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
+        });
+        try {
+          payload = await response.json();
+        } catch {
+          payload = null;
+        }
+      }
+    }
+
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      if (response.status === 401 && isJwtExpired(runtime.jwt)) {
+        throw createExpiredAuthError(runtime);
+      }
+      throw normalizeBackendError(response.status, payload, runtime);
+    }
+
+    return {
+      requestId,
+      payload: payload || {},
+    };
+  } catch (error) {
+    clearTimeout(timeout);
+
+    if (error instanceof CliError) {
+      throw error;
+    }
+
+    if (error?.name === 'AbortError') {
+      throw new CliError({
+        code: 'network_timeout',
+        message: `Request timed out after ${runtime.timeoutMs}ms`,
+        exitCode: EXIT_CODES.network,
+        retryable: true,
+        hints: [
+          { command: 'notis doctor', reason: 'Check API reachability' },
+          { command: `--timeout-ms ${runtime.timeoutMs * 2}`, reason: 'Retry with a longer timeout' },
+        ],
+      });
+    }
+
+    throw new CliError({
+      code: 'network_error',
+      message: error instanceof Error ? error.message : String(error),
+      exitCode: EXIT_CODES.network,
+      retryable: true,
+      cause: error,
+    });
+  }
+}
+
+export async function callTool({
+  runtime,
+  toolName,
+  arguments_: argumentsPayload = {},
+  idempotencyKey,
+  fileBindings = [],
+}) {
+  const requestId = idempotencyKey || (runtime.mutating ? randomUUID() : null);
+  const payload = {
+    tool_name: toolName,
+    arguments: argumentsPayload,
+    idempotency_key: requestId,
+    cli_context: {
+      output_mode: runtime.outputMode,
+      profile: runtime.profileName,
+      cwd: process.cwd(),
+      agent_mode: runtime.agentMode,
+      cli_version: runtime.cliVersion,
+    },
+  };
+
+  if (Array.isArray(fileBindings) && fileBindings.length) {
+    const bindingMetadata = fileBindings.map((binding) => {
+      const {
+        contentType,
+        localPath,
+        ...metadata
+      } = binding;
+      return metadata;
+    });
+
+    return httpRequest({
+      runtime,
+      path: '/cli_tools',
+      body: () => createMultipartFileUpload(payload, bindingMetadata, fileBindings),
+      multipart: true,
+    });
+  }
+
+  return httpRequest({
+    runtime,
+    path: '/cli_tools',
+    body: payload,
+  });
+}