@skyramp/skyramp 1.3.23 → 1.3.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/skyramp",
-  "version": "1.3.23",
+  "version": "1.3.25",
   "description": "module for leveraging skyramp cli functionality",
   "scripts": {
     "lint": "eslint 'src/**/*.js' 'src/**/*.ts' --fix",
@@ -29,6 +29,9 @@
     "koffi": "^2.15.0",
     "zod": "^3.25.3"
   },
+  "peerDependencies": {
+    "@playwright/test": ">=1.58.2"
+  },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^6.14.0",
     "@typescript-eslint/parser": "^6.14.0",

package/scripts/download-binary.js

@@ -22,7 +22,8 @@ function log(level, message) {
 }
 
 let S3_PRIVATE = process.env.S3_PRIVATE || false;  // Set to true if libraries are in a private S3 bucket
-const AWS_REGION = process.env.AWS_REGION || 'us-west-2';  // Set your AWS region
+const AWS_REGION = process.env.AWS_REGION || 'us-west-2';  // Used only for private S3 bucket access
+const PUBLIC_BUCKET_REGION = 'us-west-2';  // Fixed: public bucket region (immune to user's AWS_REGION)
 const SKIP_DOWNLOAD = process.env.SKIP_DOWNLOAD || false;  // Set to true to skip the download process
 const PUBLIC_BUCKET_NAME = process.env.INT_LIBRARY_BUCKET || 'skyramp-public';  // Set to your S3 public bucket name
 const PUBLIC_LIBRARY_PATH = process.env.INT_LIBRARY_PATH || `release/v${require('../package.json').version}/lib`;  // Set to your S3 public library root path
@@ -68,7 +69,7 @@ const prefix = 'skyramp';
 const binaryFilename = `${prefix}-${platform}-${arch}.${ext}`;
 const headerFilename = `${prefix}-${platform}-${arch}.h`;
 
-const baseUrl = `https://${PUBLIC_BUCKET_NAME}.s3.${AWS_REGION}.amazonaws.com/${PUBLIC_LIBRARY_PATH}/`;
+const baseUrl = `https://${PUBLIC_BUCKET_NAME}.s3.${PUBLIC_BUCKET_REGION}.amazonaws.com/${PUBLIC_LIBRARY_PATH}/`;
 const localDir = path.join(__dirname, '..', 'lib');
 
 const files = [
@@ -89,11 +90,24 @@ async function calculateMD5(filePath) {
     });
 }
 
-async function getETag(url) {
+const MAX_REDIRECTS = 5;
+
+async function getETag(url, redirectCount = 0) {
     return new Promise((resolve, reject) => {
         const req = https.get(url, { method: 'HEAD', timeout: HEAD_TIMEOUT_MS }, res => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                if (redirectCount >= MAX_REDIRECTS) {
+                    reject(new Error(`Too many redirects for ${url}`));
+                    return;
+                }
+                const redirectUrl = new URL(res.headers.location, url).toString();
+                log('info', `Following redirect (${res.statusCode}) to ${redirectUrl}`);
+                resolve(getETag(redirectUrl, redirectCount + 1));
+                return;
+            }
             if (res.statusCode !== 200) {
-                res.resume(); // Drain response to free the socket
+                res.resume();
                 reject(new Error(`HTTP ${res.statusCode}: ${url}`));
                 return;
             }
@@ -113,7 +127,7 @@ async function getETag(url) {
     });
 }
 
-async function download(url, dest, options = {}) {
+async function download(url, dest, options = {}, redirectCount = 0) {
     await fs.promises.mkdir(path.dirname(dest), { recursive: true });
 
     const { session, bucket, s3Key } = options;
@@ -150,8 +164,19 @@ async function download(url, dest, options = {}) {
             };
 
             const req = https.get(url, { timeout: DOWNLOAD_TIMEOUT_MS }, res => {
+                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    res.resume();
+                    if (redirectCount >= MAX_REDIRECTS) {
+                        fail(new Error(`Too many redirects for ${url}`));
+                        return;
+                    }
+                    const redirectUrl = new URL(res.headers.location, url).toString();
+                    log('info', `Following redirect (${res.statusCode}) to ${redirectUrl}`);
+                    resolve(download(redirectUrl, dest, options, redirectCount + 1));
+                    return;
+                }
                 if (res.statusCode !== 200) {
-                    res.resume(); // Drain response to free the socket
+                    res.resume();
                     const error = new Error(`HTTP ${res.statusCode}: ${url}`);
                     log('error', `Failed to download ${url}: ${error.message}`);
                     fail(error);

package/src/classes/ResponseV2.d.ts

@@ -22,4 +22,11 @@ export declare class ResponseV2 {
      */
     constructor(options?: ResponseV2Options);
     toYaml(): string;
+    toJson(): string;
+    /**
+     * Prints the response status in a formatted way with color coding.
+     * Uses the C library function PrintResponseV2Status for output.
+     * @param expectedStatusCode - The expected HTTP status code as a string (supports wildcards like "2xx", "20x")
+     */
+    print(expectedStatusCode: string): void;
 }

package/src/classes/ResponseV2.js

@@ -1,4 +1,8 @@
 const yaml = require('js-yaml');
+const lib = require('../lib');
+
+// C library function binding for PrintResponseV2Status
+const printResponseV2Status = lib.func('PrintResponseV2Status', 'void', ['str', 'str']);
 
 /**
  * Represents a REST response.
@@ -95,6 +99,24 @@ class ResponseV2 {
       }, {});
       return JSON.stringify(jsonObject, null, 2);
     }
+
+    /**
+     * Prints the response status in a formatted way with color coding.
+     * Uses the C library function PrintResponseV2Status for output.
+     * 
+     * @param {string} expectedStatusCode - The expected HTTP status code as a string (supports wildcards like "2xx", "20x")
+     */
+    print(expectedStatusCode) {
+        if (!expectedStatusCode || typeof expectedStatusCode !== 'string') {
+            throw new Error('Expected status code must be a non-empty string');
+        }
+        
+        // Convert ResponseV2 to JSON
+        const responseJson = this.toJson();
+        
+        // Call the C library function
+        printResponseV2Status(responseJson, expectedStatusCode);
+    }
 }
 
 

package/src/classes/SkyrampClient.js

@@ -48,8 +48,6 @@ const runTesterStartWrapperv1 = lib.func('runTesterStartWrapperWithGlobalHeaders
 const applyMockDescriptionWrapper = lib.func('applyMockDescriptionWrapper', 'string', ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string']);
 const applyMockObjectWrapper = lib.func('applyMockObjectWrapper', 'string', ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool']);
 const removeMocksObjectWrapper = lib.func('removeMocksObjectWrapper', 'string', []);
-// NPM only: for VS code extension use
-const initTargetWrapper = lib.func('initTargetWrapper', 'string', ['string']);
 const deployTargetWrapper = lib.func('deployTargetWrapper', 'string', ['string', 'string', 'string', 'string', 'string', 'string', 'bool']);
 const deleteTargetWrapper = lib.func('deleteTargetWrapper', 'string', ['string', 'string', 'string', 'string', 'string']);
 
@@ -92,6 +90,9 @@ const generateRestTestWrapper = lib.func('generateRestTestWrapper', 'string', [
     'string',       // playwrightSaveStoragePath
     'string',       // browser
     'string',       // device
+    'string',       // loadExtension
+    'string',       // userDataDir
+    'bool',         // pressSequentially
     'string',       // loadCount
     'string',       // loadDuration
     'string',       // loadNumThreads
@@ -675,21 +676,6 @@ class SkyrampClient {
     });
   }
 
-  // NPM only: for VS code extension use
-  async initTarget(taretName) {
-    return new Promise((resolve, reject) => {
-      initTargetWrapper.async(taretName, (err, res) => {
-        if (err) {
-          reject(err);
-        } else if (res) {
-          reject(new Error(res));
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-
   // NPM only: for VS code extension use
   async deployTarget(targetDescription, namespace, workerImage = '', localImage = false) {
     if (this.kubeConfigPath === null) {
@@ -942,6 +928,9 @@ class SkyrampClient {
         options.playwrightSaveStoragePath || "",
         options.browser || "",
         options.device || "",
+        options.loadExtension || "",
+        options.userDataDir || "",
+        options.pressSequentially || false,
         options.loadCount || "0",
         options.loadDuration || "0",
         options.loadNumThreads || "0",

package/src/classes/SmartFixture.d.ts

@@ -0,0 +1,9 @@
+import type { test as baseTest } from '@playwright/test';
+
+/**
+ * Playwright `test` object that automatically launches a persistent Chromium
+ * context with the loaded extension(s) when PLAYWRIGHT_LOAD_EXTENSION is set
+ * in the environment (PLAYWRIGHT_USER_DATA_DIR optionally pins the profile).
+ * Without those env vars it behaves identically to Playwright's default `test`.
+ */
+export const test: typeof baseTest;

package/src/classes/SmartFixture.js

@@ -0,0 +1,114 @@
+/**
+ * Skyramp's Playwright test fixture.
+ *
+ * Re-exports a `test` object that behaves like Playwright's default `test`
+ * unless extension-loading env vars are set, in which case it overrides the
+ * `context` and `page` fixtures to launch a persistent Chromium context with
+ * the given extension and (optional) user-data directory.
+ *
+ * Recognised env vars:
+ *   - PLAYWRIGHT_LOAD_EXTENSION
+ *       Comma-separated absolute paths to unpacked extensions to load.
+ *   - PLAYWRIGHT_USER_DATA_DIR
+ *       Persistent profile directory. Optional; when omitted Playwright
+ *       creates a fresh temp directory each run.
+ *
+ * Without these env vars the export is a passthrough — generated specs that
+ * `import { test } from '@skyramp/skyramp'` keep working in plain test runs.
+ * (The names are deliberately the same as the env vars the Skyramp MCP
+ * recorder reads, so a single env block covers recording + replay.)
+ *
+ * The `ignoreDefaultArgs` list mirrors what the Skyramp MCP recorder does at
+ * launch time: Playwright's Chromium defaults include `--disable-extensions`
+ * and `--disable-component-extensions-with-background-pages`, both of which
+ * silently break MV3 extension loading. Strip them so the extension's service
+ * worker actually starts.
+ */
+
+// Resolve @playwright/test starting from the consumer's project root,
+// not from skyramp's install location. When skyramp is installed in a
+// different node_modules tree than the consumer (e.g. globally), default
+// resolution would find skyramp's own copy of @playwright/test — a
+// physically different file from the one the test runner already loaded
+// — and Playwright throws "Requiring @playwright/test second time".
+// Anchoring resolution at process.cwd() makes Node walk up the consumer's
+// tree first so we share the runner's instance.
+const { test: baseTest, chromium } = require(loadPlaywrightTestPath());
+
+function loadPlaywrightTestPath() {
+  try {
+    return require.resolve('@playwright/test', { paths: [process.cwd()] });
+  } catch {
+    // Fallback for setups where @playwright/test is reachable from
+    // skyramp's tree but not from process.cwd() (development checkouts,
+    // monorepos where tests run from the package dir).
+    return '@playwright/test';
+  }
+}
+
+function envOrUndefined(name) {
+  const v = process.env[name];
+  return v && v.trim() !== '' ? v.trim() : undefined;
+}
+
+function getExtensionPaths() {
+  const raw = envOrUndefined('PLAYWRIGHT_LOAD_EXTENSION');
+  if (!raw) return [];
+  return raw.split(',').map(s => s.trim()).filter(Boolean);
+}
+
+function getUserDataDir() {
+  return envOrUndefined('PLAYWRIGHT_USER_DATA_DIR');
+}
+
+const test = baseTest.extend({
+  context: async ({ browser, browserName }, use) => {
+    const extensions = getExtensionPaths();
+    const userDataDir = getUserDataDir();
+
+    if (extensions.length === 0) {
+      // No extension requested — delegate to the inherited `browser` fixture
+      // so playwright.config (browserName, use.viewport, use.headless,
+      // launchOptions, etc.) and Playwright's per-worker browser pool are
+      // honored.
+      const ctx = await browser.newContext();
+      await use(ctx);
+      await ctx.close();
+      return;
+    }
+
+    // Playwright's extension-loading APIs (--load-extension, launchPersistentContext
+    // with extension args) are Chromium-only. Fail fast rather than silently
+    // launching Chromium and overriding the project's browser choice.
+    if (browserName !== 'chromium') {
+      throw new Error(
+        `PLAYWRIGHT_LOAD_EXTENSION is set but the project uses '${browserName}'. ` +
+        `Extension loading is only supported in Chromium today.`
+      );
+    }
+
+    const joined = extensions.join(',');
+    const ctx = await chromium.launchPersistentContext(userDataDir ?? '', {
+      headless: false, // MV3 service workers don't run headless
+      args: [
+        `--disable-extensions-except=${joined}`,
+        `--load-extension=${joined}`,
+      ],
+      ignoreDefaultArgs: [
+        '--disable-extensions',
+        '--disable-component-extensions-with-background-pages',
+      ],
+    });
+    await use(ctx);
+    await ctx.close();
+  },
+
+  page: async ({ context }, use) => {
+    // Reuse an existing page if the extension spawned one (welcome / lock
+    // screen tabs are common); otherwise open a fresh tab.
+    const page = context.pages()[0] ?? (await context.newPage());
+    await use(page);
+  },
+});
+
+module.exports = { test };

package/src/classes/SmartPlaywright.js

@@ -1,8 +1,20 @@
 /* global window */
-const { expect: playwrightExpect } = require('@playwright/test');
+// See SmartFixture.js for the rationale: resolve @playwright/test from
+// the consumer's project root so we share the runner's instance and
+// avoid "Requiring @playwright/test second time" when skyramp is
+// installed in a different node_modules tree.
+function loadPlaywrightTestPath() {
+  try {
+    return require.resolve('@playwright/test', { paths: [process.cwd()] });
+  } catch {
+    return '@playwright/test';
+  }
+}
+const { expect: playwrightExpect } = require(loadPlaywrightTestPath());
 const lib = require('../lib');
 const koffi = require('koffi');
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { PDF_VIEWER_INJECTION_SCRIPT } = require('../pdfViewer');
 
@@ -1259,6 +1271,89 @@ class SkyrampPlaywrightPage {
         return this._page.waitForResponse(arg, newOptions)
     }
 
+    /**
+     * Returns a Proxy around the underlying BrowserContext that auto-wraps
+     * any Page coming out of newPage() or waitForEvent('page') with
+     * newSkyrampPlaywrightPage. Lets codegen emit
+     *   const page2 = await page.context().newPage();
+     * and get a fully-wrapped SkyrampPlaywrightPage without the
+     * setDefaultTimeout + manual reassignment dance.
+     *
+     * All other context methods are forwarded unchanged.
+     */
+    context() {
+        const ctx = this._page.context();
+        const testInfo = this._testInfo;
+        return new Proxy(ctx, {
+            get(target, prop) {
+                if (prop === 'newPage') {
+                    return async (...args) => {
+                        const rawPage = await target.newPage(...args);
+                        return newSkyrampPlaywrightPage(rawPage, testInfo);
+                    };
+                }
+                if (prop === 'waitForEvent') {
+                    return async (event, ...args) => {
+                        const result = await target.waitForEvent(event, ...args);
+                        if (event === 'page' && result)
+                            return newSkyrampPlaywrightPage(result, testInfo);
+                        return result;
+                    };
+                }
+                const value = Reflect.get(target, prop, target);
+                if (typeof value === 'function')
+                    return value.bind(target);
+                return value;
+            },
+        });
+    }
+
+    /**
+     * Poll the browser context for a page whose URL contains `urlMatch`,
+     * returning a wrapped SkyrampPlaywrightPage once one attaches. Throws
+     * if no match appears within `timeoutMs` (default 15s).
+     *
+     * Used by Skyramp's codegen for `openPage` events that have no recorded
+     * triggering action (extension-auto-opened tabs: 1Password onboarding,
+     * Watchtower notifications, etc.) where the Promise.all wrap pattern
+     * isn't applicable. Replaces the bare `context.pages().find(...)` lookup
+     * which races against page attachment after profile init / extension
+     * service-worker boot.
+     */
+    async waitForPage(urlMatch, timeoutMs = 15000) {
+        const ctx = this._page.context();
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const found = ctx.pages().find(p => p.url().includes(urlMatch));
+            if (found) return newSkyrampPlaywrightPage(found, this._testInfo);
+            await new Promise(r => setTimeout(r, 250));
+        }
+        throw new Error(`Page matching "${urlMatch}" not found within ${timeoutMs}ms`);
+    }
+
+    /**
+     * Poll this page's frame tree for a frame whose URL contains `urlMatch`,
+     * returning the Frame once it attaches. Throws if no match appears
+     * within `timeoutMs` (default 15s).
+     *
+     * Used for chrome-extension iframes (1Password's save dialog, autofill
+     * menu, modal etc.) hosted in closed shadow roots. Standard
+     * page.locator('iframe').contentFrame() can't pierce a closed shadow
+     * root, but page.frames() (CDP-backed) sees every frame regardless.
+     * Replaces the bare `page.frames().find(...)` lookup which races against
+     * iframe attachment after a form submit (the save dialog re-attaches on
+     * the destination page after navigation tears down the original).
+     */
+    async waitForFrame(urlMatch, timeoutMs = 15000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const found = this._page.frames().find(f => f.url().includes(urlMatch));
+            if (found) return found;
+            await new Promise(r => setTimeout(r, 250));
+        }
+        throw new Error(`Frame matching "${urlMatch}" not found within ${timeoutMs}ms`);
+    }
+
     async goto(url, options) {
         // Ensure PDF setup is complete before navigating
         if (this._pdfSetupPromise) {
@@ -1267,6 +1362,28 @@ class SkyrampPlaywrightPage {
 
         const transformedUrl = transformUrlForDocker(url);
         const result = await this._page.goto(transformedUrl, options);
+
+        // Extension content-script settle. page.goto returns when the page's
+        // `load` event fires, but a Chrome extension's content script attaches
+        // via chrome.tabs.onUpdated which can fire *after* `load`. A click
+        // immediately following goto can hit before the extension is listening
+        // (1Password's inline menu, autofill detector, etc.). When the
+        // BrowserContext has an extension loaded, give the extension a moment
+        // to attach before returning.
+        try {
+            const ctx = this._page.context();
+            const sws = typeof ctx.serviceWorkers === 'function' ? ctx.serviceWorkers() : [];
+            const bps = typeof ctx.backgroundPages === 'function' ? ctx.backgroundPages() : [];
+            const hasExtension = sws.some(w => w.url && w.url().startsWith('chrome-extension://'))
+                              || bps.some(p => p.url && p.url().startsWith('chrome-extension://'));
+            if (hasExtension) {
+                debug('[SmartPlaywright] extension detected, waiting 500ms for content-script attach');
+                await this._page.waitForTimeout(500);
+            }
+        } catch (e) {
+            debug(`[SmartPlaywright] extension detection failed (${e.message}); skipping settle wait`);
+        }
+
         const content = await this._page.content();
         if (hasJavascriptWrapper(content)) {
             debug(`javascript download detected when visiting ${this._page.url()}`);
@@ -1342,6 +1459,30 @@ function newSkyrampPlaywrightPage(page, testInfo) {
     return new SkyrampPlaywrightPage(page, testInfo);
 }
 
+/**
+ * Bridge inline `style` (CSS string) -> `stylePath` (CSS file) for the duration
+ * of a single toHaveScreenshot call. Playwright's expect(...).toHaveScreenshot
+ * ignores inline `style` and only reads `stylePath`, so we materialize the
+ * string to a unique temp directory created via mkdtempSync. The directory is
+ * removed in a finally block so two unrelated specs cannot share a stale path.
+ */
+async function withStylePath(options, fn) {
+    if (!options || typeof options.style !== 'string' || !options.style.trim())
+        return await fn(options);
+    if (options.stylePath)
+        return await fn(options);
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'skyramp-style-'));
+    const filePath = path.join(dir, 'style.css');
+    fs.writeFileSync(filePath, options.style);
+    const rest = { ...options };
+    delete rest.style;
+    try {
+        return await fn({ ...rest, stylePath: filePath });
+    } finally {
+        try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) { /* best-effort */ }
+    }
+}
+
 /**
  * Wrapper class for Playwright's expect that provides auto-baseline generation for screenshots.
  * Check if snapshot exists, create if missing, then compare. Enabling single-run screenshots
@@ -1370,7 +1511,16 @@ class SkyrampPageAssertions {
     }
 
     /**
-     * Auto-generates baseline screenshots if missing
+     * Auto-generates baseline screenshots if missing.
+     *
+     * `options.style` is honored at both stages:
+     *   - page.screenshot()/locator.screenshot() (used to write the first baseline)
+     *     accepts `style` as inline CSS directly.
+     *   - expect(...).toHaveScreenshot() ignores inline `style` and only honors
+     *     `stylePath`. We bridge that here by writing the inline string to a
+     *     unique temp file (mkdtempSync + per-call directory so two parallel
+     *     specs cannot share a stale path) and forwarding it as stylePath.
+     *     The temp file is deleted in a finally block.
      */
     async toHaveScreenshot(nameOrOptions, options) {
         // wait for some time before taking snapshot
@@ -1378,12 +1528,14 @@ class SkyrampPageAssertions {
 
         // If auto-baseline disabled or no testInfo, use standard Playwright behavior
         if (!this._autoBaseline || !this._testInfo) {
-            return await this._playwrightExpectation.toHaveScreenshot(nameOrOptions, options);
+            return await withStylePath(options, (forwardedOptions) =>
+                this._playwrightExpectation.toHaveScreenshot(nameOrOptions, forwardedOptions));
         }
 
         // Only handle string names (auto-generated names not supported)
         if (typeof nameOrOptions !== 'string') {
-            return await this._playwrightExpectation.toHaveScreenshot(nameOrOptions, options);
+            return await withStylePath(options, (forwardedOptions) =>
+                this._playwrightExpectation.toHaveScreenshot(nameOrOptions, forwardedOptions));
         }
 
         // Clip coordinates are document-relative (viewport coords + scrollX/Y at record time).
@@ -1437,8 +1589,10 @@ class SkyrampPageAssertions {
             debug(`Generated baseline: ${snapshotPath}`);
         }
 
-        // Baseline exists (or just created): assert normally
-        return await this._playwrightExpectation.toHaveScreenshot(nameOrOptions, adjustedOptions);
+        // Baseline exists (or just created): assert normally. Bridge inline style
+        // to stylePath because toHaveScreenshot does not honor inline style.
+        return await withStylePath(adjustedOptions, (forwardedOptions) =>
+            this._playwrightExpectation.toHaveScreenshot(nameOrOptions, forwardedOptions));
     }
 }
 

package/src/index.d.ts

@@ -19,5 +19,6 @@ export * from "./classes/AsyncTestStatus";
 export * from "./utils";
 export * from "./function";
 export * from "./classes/SmartPlaywright";
+export * from "./classes/SmartFixture";
 export * from "./classes/GoJSDiagram";
 export * from "./workspace";

package/src/index.js

@@ -20,6 +20,7 @@ const MockV2 = require('./classes/MockV2');
 const { getValue, getResponseValue, checkSchema, iterate, pushToolEvent, getBaseUrl } = require('./utils');
 const { checkStatusCode, checkRequestPayload } = require('./function');
 const { newSkyrampPlaywrightPage, expect } = require('./classes/SmartPlaywright');
+const { test } = require('./classes/SmartFixture');
 const GoJSDiagram = require('./classes/GoJSDiagram');
 const {
   workspaceConfigSchema,
@@ -63,6 +64,7 @@ module.exports = {
   newSkyrampPlaywrightPage,
   GoJSDiagram,
   expect,
+  test,
   workspaceConfigSchema,
   serviceSchema,
   WorkspaceConfigManager,

package/src/workspace.d.ts

@@ -16,7 +16,7 @@ export interface ServiceApi {
 }
 
 export interface ServiceRuntimeDetails {
-  serverStartCommand: string;
+  serverStartCommand?: string;
   runtime: "local" | "docker" | "k8s";
   dockerNetwork?: string;
   k8sNamespace?: string;

package/src/workspace.js

@@ -41,7 +41,7 @@ const serviceSchema = z.object({
     .optional(),
   runtimeDetails: z
     .object({
-      serverStartCommand: z.string(),
+      serverStartCommand: z.string().optional(),
       runtime: z.enum(['local', 'docker', 'k8s']),
       dockerNetwork: z.string().optional(),
       k8sNamespace: z.string().optional(),