@demoscript/cli 1.1.3 → 1.1.6

package/dist/bundle.cjs

@@ -41985,6 +41985,26 @@ function mapType(schema2) {
       return "text";
   }
 }
+function getTextareaRows(schema2) {
+  if (schema2.type === "array") {
+    const itemType = schema2.items?.type;
+    if (itemType === "string" || itemType === "number" || itemType === "integer") {
+      return 2;
+    }
+    return 3;
+  }
+  if (schema2.type === "object" && schema2.properties) {
+    const propCount = Object.keys(schema2.properties).length;
+    if (propCount <= 2) {
+      return 2;
+    }
+    if (propCount <= 4) {
+      return 3;
+    }
+    return 4;
+  }
+  return 2;
+}
 function generateOptions(schema2) {
   if (schema2.enum) {
     return schema2.enum.map((v) => ({
@@ -42020,6 +42040,54 @@ function generateFormFieldsFromPath(spec, pathObj, method) {
   if (!operation) {
     return [];
   }
+  const fields = [];
+  if (operation.parameters) {
+    for (const param of operation.parameters) {
+      if (param.in === "query" || param.in === "path") {
+        let schema2;
+        if (param.schema) {
+          schema2 = resolveSchema(spec, param.schema);
+        } else {
+          if (param.type === "array" && param.items?.enum) {
+            schema2 = {
+              type: "string",
+              enum: param.items.enum,
+              default: param.items.default ?? param.default
+            };
+          } else {
+            schema2 = {
+              type: param.type || "string",
+              enum: param.enum,
+              default: param.default,
+              format: param.format
+            };
+          }
+        }
+        const fieldType = mapType(schema2);
+        const field = {
+          name: param.name,
+          label: param.description || param.name,
+          type: fieldType,
+          required: param.required ?? false,
+          paramIn: param.in
+        };
+        if (schema2.default !== void 0) {
+          field.default = schema2.default;
+        }
+        const options = generateOptions(schema2);
+        if (options) {
+          field.options = options;
+        }
+        if (param.description) {
+          field.placeholder = param.description;
+        }
+        if (fieldType === "textarea") {
+          field.rows = getTextareaRows(schema2);
+        }
+        fields.push(field);
+      }
+    }
+  }
   let bodySchema = null;
   if (operation.requestBody) {
     const jsonContent = operation.requestBody.content["application/json"];
@@ -42033,34 +42101,36 @@ function generateFormFieldsFromPath(spec, pathObj, method) {
       bodySchema = bodyParam.schema;
     }
   }
-  if (!bodySchema) {
-    return [];
-  }
-  const schema2 = resolveSchema(spec, bodySchema);
-  if (!schema2.properties) {
-    return [];
-  }
-  const requiredFields = schema2.required || [];
-  const fields = [];
-  for (const [name, propSchema] of Object.entries(schema2.properties)) {
-    const resolved = resolveSchema(spec, propSchema);
-    const field = {
-      name,
-      label: resolved.description || name,
-      type: mapType(resolved),
-      required: requiredFields.includes(name)
-    };
-    if (resolved.default !== void 0) {
-      field.default = resolved.default;
-    }
-    const options = generateOptions(resolved);
-    if (options) {
-      field.options = options;
-    }
-    if (resolved.description && field.label === name) {
-      field.placeholder = resolved.description;
+  if (bodySchema) {
+    const schema2 = resolveSchema(spec, bodySchema);
+    if (schema2.properties) {
+      const requiredFields = schema2.required || [];
+      for (const [name, propSchema] of Object.entries(schema2.properties)) {
+        const resolved = resolveSchema(spec, propSchema);
+        const fieldType = mapType(resolved);
+        const field = {
+          name,
+          label: resolved.description || name,
+          type: fieldType,
+          required: requiredFields.includes(name),
+          paramIn: "body"
+        };
+        if (resolved.default !== void 0) {
+          field.default = resolved.default;
+        }
+        const options = generateOptions(resolved);
+        if (options) {
+          field.options = options;
+        }
+        if (resolved.description && field.label === name) {
+          field.placeholder = resolved.description;
+        }
+        if (fieldType === "textarea") {
+          field.rows = getTextareaRows(resolved);
+        }
+        fields.push(field);
+      }
     }
-    fields.push(field);
   }
   return fields;
 }
@@ -42235,6 +42305,12 @@ function createRestProxy() {
       return;
     }
     try {
+      let absoluteUrl = url;
+      if (url.startsWith("/")) {
+        const protocol = req.protocol;
+        const host = req.get("host") || "localhost";
+        absoluteUrl = `${protocol}://${host}${url}`;
+      }
       const fetchHeaders = {
         "Content-Type": "application/json",
         ...headers
@@ -42246,7 +42322,7 @@ function createRestProxy() {
       if (body && method !== "GET") {
         fetchOptions.body = JSON.stringify(body);
       }
-      const response = await fetch(url, fetchOptions);
+      const response = await fetch(absoluteUrl, fetchOptions);
       const responseBody = await response.json().catch(() => null);
       res.json({
         status: response.status,
@@ -42315,6 +42391,1016 @@ function executeCommand(command, options) {
   });
 }
 
+// ../shared/dist/sandbox/openapi.js
+var sandboxOpenApiSpec = {
+  openapi: "3.0.3",
+  info: {
+    title: "DemoScript Sandbox API",
+    version: "1.0.0",
+    description: "A mock API for testing DemoScript demos. Provides user management, async jobs, authentication, and utility endpoints.",
+    contact: {
+      name: "DemoScript",
+      url: "https://demoscript.app"
+    }
+  },
+  servers: [
+    { url: "/sandbox", description: "Local CLI" },
+    { url: "https://demoscript.app/api/sandbox", description: "DemoScript Cloud" }
+  ],
+  tags: [
+    { name: "health", description: "Health check endpoints" },
+    { name: "auth", description: "Authentication endpoints" },
+    { name: "users", description: "User management" },
+    { name: "jobs", description: "Async job management" },
+    { name: "utility", description: "Utility endpoints" }
+  ],
+  paths: {
+    "/health": {
+      get: {
+        tags: ["health"],
+        summary: "Health check",
+        description: "Returns the health status of the API",
+        operationId: "getHealth",
+        responses: {
+          "200": {
+            description: "API is healthy",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    status: { type: "string", example: "ok" },
+                    timestamp: { type: "string", format: "date-time" },
+                    version: { type: "string", example: "1.0.0" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/auth/login": {
+      post: {
+        tags: ["auth"],
+        summary: "Authenticate user",
+        description: "Login with email and password to get an authentication token",
+        operationId: "login",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                required: ["email", "password"],
+                properties: {
+                  email: {
+                    type: "string",
+                    format: "email",
+                    description: "User email address",
+                    example: "demo@example.com"
+                  },
+                  password: {
+                    type: "string",
+                    format: "password",
+                    description: "User password (any value accepted in sandbox)",
+                    example: "demo123"
+                  }
+                }
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Successfully authenticated",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/AuthResponse" }
+              }
+            }
+          },
+          "401": {
+            description: "Invalid credentials",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/users": {
+      get: {
+        tags: ["users"],
+        summary: "List users",
+        description: "Get a paginated list of all users",
+        operationId: "listUsers",
+        security: [{ bearerAuth: [] }],
+        parameters: [
+          {
+            name: "page",
+            in: "query",
+            description: "Page number (1-indexed)",
+            schema: { type: "integer", minimum: 1, default: 1 }
+          },
+          {
+            name: "limit",
+            in: "query",
+            description: "Items per page",
+            schema: { type: "integer", minimum: 1, maximum: 100, default: 10 }
+          },
+          {
+            name: "role",
+            in: "query",
+            description: "Filter by role",
+            schema: { type: "string", enum: ["admin", "user", "viewer"] }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "List of users",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    users: {
+                      type: "array",
+                      items: { $ref: "#/components/schemas/User" }
+                    },
+                    total: { type: "integer", description: "Total number of users" },
+                    page: { type: "integer", description: "Current page" },
+                    limit: { type: "integer", description: "Items per page" },
+                    totalPages: { type: "integer", description: "Total number of pages" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        tags: ["users"],
+        summary: "Create user",
+        description: "Create a new user",
+        operationId: "createUser",
+        security: [{ bearerAuth: [] }],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                required: ["email", "name"],
+                properties: {
+                  email: {
+                    type: "string",
+                    format: "email",
+                    description: "User email address",
+                    example: "newuser@example.com"
+                  },
+                  name: {
+                    type: "string",
+                    description: "User full name",
+                    example: "New User"
+                  },
+                  role: {
+                    type: "string",
+                    enum: ["admin", "user", "viewer"],
+                    default: "user",
+                    description: "User role"
+                  }
+                }
+              }
+            }
+          }
+        },
+        responses: {
+          "201": {
+            description: "User created",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/User" }
+              }
+            }
+          },
+          "400": {
+            description: "Invalid input",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          },
+          "409": {
+            description: "Email already exists",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/users/{id}": {
+      get: {
+        tags: ["users"],
+        summary: "Get user",
+        description: "Get a user by ID",
+        operationId: "getUser",
+        security: [{ bearerAuth: [] }],
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            description: "User ID",
+            schema: { type: "string" }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "User found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/User" }
+              }
+            }
+          },
+          "404": {
+            description: "User not found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        }
+      },
+      put: {
+        tags: ["users"],
+        summary: "Update user",
+        description: "Update an existing user",
+        operationId: "updateUser",
+        security: [{ bearerAuth: [] }],
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            description: "User ID",
+            schema: { type: "string" }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  email: {
+                    type: "string",
+                    format: "email",
+                    description: "User email address"
+                  },
+                  name: {
+                    type: "string",
+                    description: "User full name"
+                  },
+                  role: {
+                    type: "string",
+                    enum: ["admin", "user", "viewer"],
+                    description: "User role"
+                  }
+                }
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "User updated",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/User" }
+              }
+            }
+          },
+          "404": {
+            description: "User not found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        }
+      },
+      delete: {
+        tags: ["users"],
+        summary: "Delete user",
+        description: "Delete a user by ID",
+        operationId: "deleteUser",
+        security: [{ bearerAuth: [] }],
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            description: "User ID",
+            schema: { type: "string" }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "User deleted",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    success: { type: "boolean", example: true },
+                    message: { type: "string", example: "User deleted" }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            description: "User not found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/jobs": {
+      get: {
+        tags: ["jobs"],
+        summary: "List jobs",
+        description: "Get a list of all async jobs",
+        operationId: "listJobs",
+        security: [{ bearerAuth: [] }],
+        parameters: [
+          {
+            name: "status",
+            in: "query",
+            description: "Filter by status",
+            schema: { type: "string", enum: ["pending", "running", "completed", "failed"] }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "List of jobs",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    jobs: {
+                      type: "array",
+                      items: { $ref: "#/components/schemas/Job" }
+                    },
+                    total: { type: "integer", description: "Total number of jobs" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        tags: ["jobs"],
+        summary: "Create job",
+        description: "Create a new async job. The job will progress through pending -> running -> completed over ~3 seconds.",
+        operationId: "createJob",
+        security: [{ bearerAuth: [] }],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                required: ["type"],
+                properties: {
+                  type: {
+                    type: "string",
+                    enum: ["export", "import", "process"],
+                    description: "Type of job to create",
+                    example: "export"
+                  }
+                }
+              }
+            }
+          }
+        },
+        responses: {
+          "201": {
+            description: "Job created",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Job" }
+              }
+            }
+          },
+          "400": {
+            description: "Invalid input",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/jobs/{id}": {
+      get: {
+        tags: ["jobs"],
+        summary: "Get job status",
+        description: "Get the current status of an async job. Poll this endpoint to track job progress.",
+        operationId: "getJob",
+        security: [{ bearerAuth: [] }],
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            description: "Job ID",
+            schema: { type: "string" }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Job found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Job" }
+              }
+            }
+          },
+          "404": {
+            description: "Job not found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/echo": {
+      post: {
+        tags: ["utility"],
+        summary: "Echo request",
+        description: "Returns the request body back in the response. Useful for testing.",
+        operationId: "echo",
+        requestBody: {
+          required: false,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                additionalProperties: true,
+                description: "Any JSON object",
+                example: { message: "Hello, World!", number: 42 }
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Echo response",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    echo: {
+                      type: "object",
+                      additionalProperties: true,
+                      description: "The request body that was sent"
+                    },
+                    timestamp: { type: "string", format: "date-time" },
+                    method: { type: "string", example: "POST" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/error/{code}": {
+      get: {
+        tags: ["utility"],
+        summary: "Generate error",
+        description: "Returns a specific HTTP error code. Useful for testing error handling.",
+        operationId: "generateError",
+        parameters: [
+          {
+            name: "code",
+            in: "path",
+            required: true,
+            description: "HTTP status code to return",
+            schema: {
+              type: "integer",
+              enum: [400, 401, 403, 404, 500, 502, 503]
+            }
+          }
+        ],
+        responses: {
+          "400": {
+            description: "Bad Request",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          },
+          "401": {
+            description: "Unauthorized",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          },
+          "403": {
+            description: "Forbidden",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          },
+          "404": {
+            description: "Not Found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          },
+          "500": {
+            description: "Internal Server Error",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          },
+          "502": {
+            description: "Bad Gateway",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          },
+          "503": {
+            description: "Service Unavailable",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  components: {
+    schemas: {
+      User: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Unique user ID", example: "lx1abc-1" },
+          email: { type: "string", format: "email", description: "User email", example: "user@example.com" },
+          name: { type: "string", description: "User full name", example: "John Doe" },
+          role: { type: "string", enum: ["admin", "user", "viewer"], description: "User role" },
+          createdAt: { type: "string", format: "date-time", description: "Creation timestamp" },
+          updatedAt: { type: "string", format: "date-time", description: "Last update timestamp" }
+        },
+        required: ["id", "email", "name", "role", "createdAt", "updatedAt"]
+      },
+      Job: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Unique job ID", example: "lx1def-2" },
+          type: { type: "string", enum: ["export", "import", "process"], description: "Job type" },
+          status: { type: "string", enum: ["pending", "running", "completed", "failed"], description: "Current job status" },
+          progress: { type: "integer", minimum: 0, maximum: 100, description: "Progress percentage" },
+          result: { type: "object", additionalProperties: true, description: "Job result (when completed)" },
+          createdAt: { type: "string", format: "date-time", description: "Creation timestamp" },
+          completedAt: { type: "string", format: "date-time", description: "Completion timestamp" }
+        },
+        required: ["id", "type", "status", "progress", "createdAt"]
+      },
+      AuthResponse: {
+        type: "object",
+        properties: {
+          token: { type: "string", description: "Bearer token for authentication", example: "sandbox_lx1ghi-3_abc123" },
+          user: { $ref: "#/components/schemas/User" },
+          expiresAt: { type: "string", format: "date-time", description: "Token expiration time" }
+        },
+        required: ["token", "user", "expiresAt"]
+      },
+      Error: {
+        type: "object",
+        properties: {
+          error: { type: "string", description: "Error message", example: "Not found" },
+          code: { type: "string", description: "Error code", example: "NOT_FOUND" },
+          details: { type: "object", additionalProperties: true, description: "Additional error details" }
+        },
+        required: ["error", "code"]
+      }
+    },
+    securitySchemes: {
+      bearerAuth: {
+        type: "http",
+        scheme: "bearer",
+        description: "Use the token from /auth/login as Bearer token"
+      }
+    }
+  }
+};
+
+// ../shared/dist/sandbox/data.js
+var sessions = /* @__PURE__ */ new Map();
+var defaultStore;
+var seedUsers = [
+  { email: "admin@example.com", name: "Admin User", role: "admin" },
+  { email: "alice@example.com", name: "Alice Johnson", role: "user" },
+  { email: "bob@example.com", name: "Bob Smith", role: "user" },
+  { email: "demo@example.com", name: "Demo User", role: "viewer" }
+];
+function generateIdForStore(store) {
+  return `${Date.now().toString(36)}-${(++store.idCounter).toString(36)}`;
+}
+function createFreshStore() {
+  const store = {
+    users: /* @__PURE__ */ new Map(),
+    jobs: /* @__PURE__ */ new Map(),
+    tokens: /* @__PURE__ */ new Map(),
+    idCounter: 0
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const userData of seedUsers) {
+    const id = generateIdForStore(store);
+    store.users.set(id, {
+      ...userData,
+      id,
+      createdAt: now,
+      updatedAt: now
+    });
+  }
+  return store;
+}
+defaultStore = createFreshStore();
+function getStore(sessionId) {
+  if (sessionId) {
+    const session = sessions.get(sessionId);
+    if (session)
+      return session;
+  }
+  return defaultStore;
+}
+function getUsers(sessionId) {
+  return Array.from(getStore(sessionId).users.values());
+}
+function getUserById(id, sessionId) {
+  return getStore(sessionId).users.get(id);
+}
+function getUserByEmail(email, sessionId) {
+  return Array.from(getStore(sessionId).users.values()).find((u) => u.email === email);
+}
+function createUser(data, sessionId) {
+  const store = getStore(sessionId);
+  const id = generateIdForStore(store);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const user = {
+    id,
+    email: data.email,
+    name: data.name,
+    role: data.role || "user",
+    createdAt: now,
+    updatedAt: now
+  };
+  store.users.set(id, user);
+  return user;
+}
+function updateUser(id, data, sessionId) {
+  const store = getStore(sessionId);
+  const user = store.users.get(id);
+  if (!user)
+    return void 0;
+  const updated = {
+    ...user,
+    ...data,
+    id: user.id,
+    createdAt: user.createdAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  store.users.set(id, updated);
+  return updated;
+}
+function deleteUser(id, sessionId) {
+  return getStore(sessionId).users.delete(id);
+}
+function getJobs(sessionId) {
+  return Array.from(getStore(sessionId).jobs.values());
+}
+function getJobById(id, sessionId) {
+  return getStore(sessionId).jobs.get(id);
+}
+function createJob(data, sessionId) {
+  const store = getStore(sessionId);
+  const id = generateIdForStore(store);
+  const job = {
+    id,
+    type: data.type,
+    status: "pending",
+    progress: 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  store.jobs.set(id, job);
+  if (!sessionId) {
+    simulateJobProgress(id, sessionId);
+  } else {
+    store.jobs.set(id, {
+      ...job,
+      status: "completed",
+      progress: 100,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      result: { message: "Job completed successfully", processedItems: 42 }
+    });
+  }
+  return store.jobs.get(id);
+}
+function updateJob(id, data, sessionId) {
+  const store = getStore(sessionId);
+  const job = store.jobs.get(id);
+  if (!job)
+    return void 0;
+  const updated = {
+    ...job,
+    ...data,
+    id: job.id,
+    createdAt: job.createdAt
+  };
+  store.jobs.set(id, updated);
+  return updated;
+}
+function simulateJobProgress(jobId, sessionId) {
+  const progressSteps = [
+    { delay: 500, progress: 0, status: "running" },
+    { delay: 1e3, progress: 25, status: "running" },
+    { delay: 1500, progress: 50, status: "running" },
+    { delay: 2e3, progress: 75, status: "running" },
+    { delay: 2500, progress: 100, status: "completed" }
+  ];
+  const store = getStore(sessionId);
+  for (const step of progressSteps) {
+    setTimeout(() => {
+      const job = store.jobs.get(jobId);
+      if (job && job.status !== "failed") {
+        updateJob(jobId, {
+          progress: step.progress,
+          status: step.status,
+          ...step.status === "completed" ? {
+            completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            result: { message: "Job completed successfully", processedItems: 42 }
+          } : {}
+        }, sessionId);
+      }
+    }, step.delay);
+  }
+}
+function createToken(userId, sessionId) {
+  const store = getStore(sessionId);
+  const token = `sandbox_${generateIdForStore(store)}_${Math.random().toString(36).substring(2)}`;
+  store.tokens.set(token, userId);
+  return token;
+}
+
+// ../shared/dist/sandbox/handlers.js
+function errorResponse(status, error, code, details) {
+  return {
+    status,
+    body: { error, code, ...details ? { details } : {} }
+  };
+}
+function successResponse(status, body) {
+  return { status, body };
+}
+function matchRoute(path2, pattern) {
+  const paramNames = [];
+  const regexPattern = pattern.replace(/\{([^}]+)\}/g, (_, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  });
+  const regex = new RegExp(`^${regexPattern}$`);
+  const match = path2.match(regex);
+  if (!match)
+    return null;
+  const params = {};
+  paramNames.forEach((name, index) => {
+    params[name] = match[index + 1];
+  });
+  return params;
+}
+function handleHealth() {
+  return successResponse(200, {
+    status: "ok",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "1.0.0"
+  });
+}
+function handleLogin(req) {
+  const body = req.body;
+  const sessionId = req.sessionId;
+  if (!body?.email || !body?.password) {
+    return errorResponse(400, "Email and password are required", "INVALID_INPUT");
+  }
+  let user = getUserByEmail(body.email, sessionId);
+  if (!user) {
+    user = createUser({ email: body.email, name: body.email.split("@")[0], role: "user" }, sessionId);
+  }
+  const token = createToken(user.id, sessionId);
+  const expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString();
+  return successResponse(200, { token, user, expiresAt });
+}
+function handleListUsers(req) {
+  const query = req.query || {};
+  const page = parseInt(String(query.page || "1"), 10);
+  const limit = Math.min(parseInt(String(query.limit || "10"), 10), 100);
+  const roleFilter = query.role;
+  const sessionId = req.sessionId;
+  let users = getUsers(sessionId);
+  if (roleFilter && ["admin", "user", "viewer"].includes(roleFilter)) {
+    users = users.filter((u) => u.role === roleFilter);
+  }
+  const total = users.length;
+  const totalPages = Math.ceil(total / limit);
+  const start = (page - 1) * limit;
+  const paginatedUsers = users.slice(start, start + limit);
+  return successResponse(200, {
+    users: paginatedUsers,
+    total,
+    page,
+    limit,
+    totalPages
+  });
+}
+function handleCreateUser(req) {
+  const body = req.body;
+  const sessionId = req.sessionId;
+  if (!body?.email || !body?.name) {
+    return errorResponse(400, "Email and name are required", "INVALID_INPUT");
+  }
+  if (getUserByEmail(body.email, sessionId)) {
+    return errorResponse(409, "Email already exists", "DUPLICATE_EMAIL");
+  }
+  const user = createUser({
+    email: body.email,
+    name: body.name,
+    role: body.role
+  }, sessionId);
+  return successResponse(201, user);
+}
+function handleGetUser(userId, sessionId) {
+  const user = getUserById(userId, sessionId);
+  if (!user) {
+    return errorResponse(404, "User not found", "NOT_FOUND");
+  }
+  return successResponse(200, user);
+}
+function handleUpdateUser(userId, req) {
+  const body = req.body;
+  const sessionId = req.sessionId;
+  if (!body || Object.keys(body).length === 0) {
+    return errorResponse(400, "No update fields provided", "INVALID_INPUT");
+  }
+  const user = updateUser(userId, body, sessionId);
+  if (!user) {
+    return errorResponse(404, "User not found", "NOT_FOUND");
+  }
+  return successResponse(200, user);
+}
+function handleDeleteUser(userId, sessionId) {
+  const deleted = deleteUser(userId, sessionId);
+  if (!deleted) {
+    return errorResponse(404, "User not found", "NOT_FOUND");
+  }
+  return successResponse(200, { success: true, message: "User deleted" });
+}
+function handleListJobs(req) {
+  const query = req.query || {};
+  const statusFilter = query.status;
+  const sessionId = req.sessionId;
+  let jobs = getJobs(sessionId);
+  if (statusFilter && ["pending", "running", "completed", "failed"].includes(statusFilter)) {
+    jobs = jobs.filter((j) => j.status === statusFilter);
+  }
+  return successResponse(200, { jobs, total: jobs.length });
+}
+function handleCreateJob(req) {
+  const body = req.body;
+  const sessionId = req.sessionId;
+  if (!body?.type || !["export", "import", "process"].includes(body.type)) {
+    return errorResponse(400, "Valid job type is required (export, import, process)", "INVALID_INPUT");
+  }
+  const job = createJob({ type: body.type }, sessionId);
+  return successResponse(201, job);
+}
+function handleGetJob(jobId, sessionId) {
+  const job = getJobById(jobId, sessionId);
+  if (!job) {
+    return errorResponse(404, "Job not found", "NOT_FOUND");
+  }
+  return successResponse(200, job);
+}
+function handleEcho(req) {
+  return successResponse(200, {
+    echo: req.body || {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    method: req.method
+  });
+}
+function handleError(code) {
+  const statusCode = parseInt(code, 10);
+  const errorMessages = {
+    400: { error: "Bad Request", code: "BAD_REQUEST" },
+    401: { error: "Unauthorized", code: "UNAUTHORIZED" },
+    403: { error: "Forbidden", code: "FORBIDDEN" },
+    404: { error: "Not Found", code: "NOT_FOUND" },
+    500: { error: "Internal Server Error", code: "INTERNAL_ERROR" },
+    502: { error: "Bad Gateway", code: "BAD_GATEWAY" },
+    503: { error: "Service Unavailable", code: "SERVICE_UNAVAILABLE" }
+  };
+  const errorInfo = errorMessages[statusCode];
+  if (!errorInfo) {
+    return errorResponse(400, "Invalid error code", "INVALID_ERROR_CODE");
+  }
+  return errorResponse(statusCode, errorInfo.error, errorInfo.code);
+}
+async function handleSandboxRequest(req) {
+  const path2 = req.path.startsWith("/") ? req.path : `/${req.path}`;
+  const method = req.method.toUpperCase();
+  const sessionId = req.sessionId;
+  if (path2 === "/health" && method === "GET") {
+    return handleHealth();
+  }
+  if (path2 === "/openapi.json" && method === "GET") {
+    return errorResponse(404, "OpenAPI spec should be served by framework", "NOT_IMPLEMENTED");
+  }
+  if (path2 === "/auth/login" && method === "POST") {
+    return handleLogin(req);
+  }
+  if (path2 === "/echo" && method === "POST") {
+    return handleEcho(req);
+  }
+  const errorMatch = matchRoute(path2, "/error/{code}");
+  if (errorMatch && method === "GET") {
+    return handleError(errorMatch.code);
+  }
+  if (path2 === "/users") {
+    if (method === "GET")
+      return handleListUsers(req);
+    if (method === "POST")
+      return handleCreateUser(req);
+  }
+  const userMatch = matchRoute(path2, "/users/{id}");
+  if (userMatch) {
+    if (method === "GET")
+      return handleGetUser(userMatch.id, sessionId);
+    if (method === "PUT")
+      return handleUpdateUser(userMatch.id, req);
+    if (method === "DELETE")
+      return handleDeleteUser(userMatch.id, sessionId);
+  }
+  if (path2 === "/jobs") {
+    if (method === "GET")
+      return handleListJobs(req);
+    if (method === "POST")
+      return handleCreateJob(req);
+  }
+  const jobMatch = matchRoute(path2, "/jobs/{id}");
+  if (jobMatch && method === "GET") {
+    return handleGetJob(jobMatch.id, sessionId);
+  }
+  return errorResponse(404, `Route not found: ${method} ${path2}`, "NOT_FOUND");
+}
+
 // ../../node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
@@ -42841,6 +43927,26 @@ async function serve(demoPath, options) {
   const wsClients = /* @__PURE__ */ new Set();
   app.post("/api/execute", createRestProxy());
   app.post("/api/execute-shell", createShellExecutor());
+  app.get("/sandbox/openapi.json", (_req, res) => {
+    res.json(sandboxOpenApiSpec);
+  });
+  async function sandboxHandler(req, res) {
+    try {
+      const sandboxPath = req.path.replace("/sandbox", "") || "/";
+      const response = await handleSandboxRequest({
+        method: req.method,
+        path: sandboxPath,
+        body: req.body,
+        headers: req.headers
+      });
+      res.status(response.status).json(response.body);
+    } catch (err) {
+      console.error("Sandbox error:", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "Sandbox error" });
+    }
+  }
+  app.all("/sandbox", sandboxHandler);
+  app.all("/sandbox/*", sandboxHandler);
   app.post("/api/open-browser", async (req, res) => {
     try {
       const { url } = req.body;
@@ -43247,11 +44353,28 @@ async function whoami() {
 var import_path6 = require("path");
 var import_url3 = require("url");
 var import_fs8 = require("fs");
+var import_os4 = require("os");
+var import_child_process2 = require("child_process");
 var import_express2 = __toESM(require_express2(), 1);
+init_js_yaml();
+var CONFIG_FILE2 = (0, import_path6.join)((0, import_os4.homedir)(), ".demoscript", "config.json");
+var DEFAULT_API_URL2 = "https://demoscript.app";
+function loadCliConfig() {
+  try {
+    if ((0, import_fs8.existsSync)(CONFIG_FILE2)) {
+      const content = (0, import_fs8.readFileSync)(CONFIG_FILE2, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {};
+}
+function getApiUrl2() {
+  return loadCliConfig().apiUrl || DEFAULT_API_URL2;
+}
 var __dirname4 = (0, import_path6.dirname)((0, import_url3.fileURLToPath)(importMetaUrl));
 function getNetworkUrl2(port) {
-  const { networkInterfaces: networkInterfaces2 } = require("os");
-  const nets = networkInterfaces2();
+  const nets = (0, import_os4.networkInterfaces)();
   for (const name of Object.keys(nets)) {
     for (const net of nets[name] || []) {
       if (net.family === "IPv4" && !net.internal) {
@@ -43261,6 +44384,113 @@ function getNetworkUrl2(port) {
   }
   return null;
 }
+function createGraphQLProxy() {
+  return async (req, res) => {
+    try {
+      const { endpoint, query, variables, headers } = req.body;
+      if (!endpoint || !query) {
+        res.status(400).json({ error: "Missing endpoint or query" });
+        return;
+      }
+      try {
+        const parsedUrl = new URL(endpoint);
+        if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+          res.status(400).json({ error: "Endpoint must be an HTTP or HTTPS URL" });
+          return;
+        }
+      } catch {
+        res.status(400).json({ error: `Invalid endpoint URL: ${endpoint}` });
+        return;
+      }
+      const fetchHeaders = {
+        "Content-Type": "application/json",
+        ...headers
+      };
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: fetchHeaders,
+        body: JSON.stringify({
+          query,
+          variables
+        })
+      });
+      const responseBody = await response.json().catch(() => null);
+      if (!response.ok) {
+        res.status(response.status).json({
+          error: responseBody?.errors?.[0]?.message || `Request failed with status ${response.status}`,
+          ...responseBody || {}
+        });
+        return;
+      }
+      res.json(responseBody);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "GraphQL request failed";
+      console.error("[GraphQL Proxy Error]", errorMessage);
+      try {
+        res.status(500).json({ error: errorMessage });
+      } catch {
+      }
+    }
+  };
+}
+function createShellExecutor2() {
+  return async (req, res) => {
+    try {
+      const body = req.body || {};
+      const { command, shell_type, workdir, env: env2 } = body;
+      if (!command) {
+        res.status(400).json({ error: "Missing command" });
+        return;
+      }
+      const result = await executeCommand2(command, {
+        shell: shell_type || true,
+        cwd: workdir,
+        env: { ...process.env, ...env2 }
+      });
+      res.json({
+        stdout: result.stdout,
+        stderr: result.stderr,
+        status: result.status,
+        output: result.stdout
+        // Legacy alias
+      });
+    } catch (err) {
+      console.error("[Shell Executor Error]", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "Command execution failed" });
+    }
+  };
+}
+function executeCommand2(command, options) {
+  return new Promise((resolve6) => {
+    const shell = typeof options.shell === "string" ? options.shell : "/bin/sh";
+    const child = (0, import_child_process2.spawn)(shell, ["-c", command], {
+      cwd: options.cwd,
+      env: options.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve6({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        status: code ?? 1
+      });
+    });
+    child.on("error", (err) => {
+      resolve6({
+        stdout: "",
+        stderr: err.message,
+        status: 1
+      });
+    });
+  });
+}
 function createRestProxy2() {
   return async (req, res) => {
     const { url, method, headers, body } = req.body;
@@ -43268,6 +44498,21 @@ function createRestProxy2() {
       return res.status(400).json({ error: "URL is required" });
     }
     try {
+      if (url.startsWith("/sandbox")) {
+        const sandboxPath = url.replace("/sandbox", "") || "/";
+        const result = await handleSandboxRequest({
+          method: method || "GET",
+          path: sandboxPath,
+          params: {},
+          query: {},
+          body
+        });
+        return res.json({
+          status: result.status,
+          headers: { "content-type": "application/json" },
+          data: result.body
+        });
+      }
       const fetchHeaders = {};
       if (headers) {
         Object.assign(fetchHeaders, headers);
@@ -43301,10 +44546,12 @@ function createRestProxy2() {
 }
 async function builder(options) {
   const { port, host, open: open3 } = options;
-  console.log(source_default.blue("Starting DemoScript Builder..."));
+  console.log(source_default.blue("Starting DemoScript Visual Editor..."));
   const app = (0, import_express2.default)();
   app.use(import_express2.default.json());
   app.post("/api/execute", createRestProxy2());
+  app.post("/api/execute-shell", createShellExecutor2());
+  app.post("/api/execute-graphql", createGraphQLProxy());
   app.get("/api/openapi", async (req, res) => {
     const url = req.query.url;
     if (!url) {
@@ -43321,6 +44568,167 @@ async function builder(options) {
       res.status(500).json({ error: err instanceof Error ? err.message : "Failed to fetch OpenAPI spec" });
     }
   });
+  app.get("/sandbox/openapi.json", (_req, res) => {
+    res.json(sandboxOpenApiSpec);
+  });
+  async function sandboxHandler(req, res) {
+    const sandboxPath = req.path.replace("/sandbox", "") || "/";
+    const result = await handleSandboxRequest({
+      method: req.method,
+      path: sandboxPath,
+      params: req.params,
+      query: req.query,
+      body: req.body
+    });
+    res.status(result.status).json(result.body);
+  }
+  app.all("/sandbox", sandboxHandler);
+  app.all("/sandbox/*", sandboxHandler);
+  let loadedDemoPath = null;
+  let loadedDemoConfig = null;
+  if (options.demoPath) {
+    const resolvedPath = (0, import_path6.resolve)(process.cwd(), options.demoPath);
+    const demoFile = resolvedPath.endsWith(".yaml") || resolvedPath.endsWith(".yml") ? resolvedPath : (0, import_path6.resolve)(resolvedPath, "demo.yaml");
+    if ((0, import_fs8.existsSync)(demoFile)) {
+      try {
+        const content = (0, import_fs8.readFileSync)(demoFile, "utf-8");
+        loadedDemoConfig = jsYaml.load(content);
+        loadedDemoPath = demoFile;
+        console.log(source_default.gray(`  Demo: ${demoFile}`));
+      } catch (err) {
+        console.error(source_default.yellow(`  Warning: Failed to load demo: ${err instanceof Error ? err.message : "Unknown error"}`));
+      }
+    } else {
+      console.error(source_default.yellow(`  Warning: Demo file not found: ${demoFile}`));
+    }
+  }
+  app.get("/api/editor/demo", (_req, res) => {
+    res.json({
+      path: loadedDemoPath,
+      config: loadedDemoConfig
+    });
+  });
+  app.get("/api/files", (req, res) => {
+    const dir = req.query.dir || process.cwd();
+    try {
+      const resolvedDir = (0, import_path6.resolve)(dir);
+      const entries = (0, import_fs8.readdirSync)(resolvedDir, { withFileTypes: true });
+      const items = entries.filter((e) => !e.name.startsWith(".")).map((e) => ({
+        name: e.name,
+        path: (0, import_path6.join)(resolvedDir, e.name),
+        isDirectory: e.isDirectory(),
+        isYaml: e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml"))
+      })).sort((a, b) => {
+        if (a.isDirectory !== b.isDirectory)
+          return a.isDirectory ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+      res.json({
+        path: resolvedDir,
+        parent: (0, import_path6.dirname)(resolvedDir),
+        items
+      });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Failed to list directory" });
+    }
+  });
+  app.get("/api/file", (req, res) => {
+    const filePath = req.query.path;
+    if (!filePath) {
+      return res.status(400).json({ error: "path query parameter is required" });
+    }
+    try {
+      const resolvedPath = (0, import_path6.resolve)(filePath);
+      if (!(0, import_fs8.existsSync)(resolvedPath)) {
+        return res.status(404).json({ error: "File not found" });
+      }
+      const content = (0, import_fs8.readFileSync)(resolvedPath, "utf-8");
+      res.json({ path: resolvedPath, content });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Failed to read file" });
+    }
+  });
+  app.post("/api/file", (req, res) => {
+    const { path: filePath, content } = req.body;
+    if (!filePath || content === void 0) {
+      return res.status(400).json({ error: "path and content are required" });
+    }
+    try {
+      const resolvedPath = (0, import_path6.resolve)(filePath);
+      const dir = (0, import_path6.dirname)(resolvedPath);
+      if (!(0, import_fs8.existsSync)(dir)) {
+        (0, import_fs8.mkdirSync)(dir, { recursive: true });
+      }
+      (0, import_fs8.writeFileSync)(resolvedPath, content, "utf-8");
+      loadedDemoPath = resolvedPath;
+      res.json({ success: true, path: resolvedPath });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Failed to save file" });
+    }
+  });
+  app.get("/api/auth/status", (_req, res) => {
+    const config = loadCliConfig();
+    res.json({
+      isLoggedIn: !!config.token,
+      username: config.username,
+      email: config.email
+    });
+  });
+  app.post("/api/push", async (req, res) => {
+    const config = loadCliConfig();
+    const apiUrl = getApiUrl2();
+    if (!config.token) {
+      return res.status(401).json({ error: "Not logged in. Run `demoscript login` first." });
+    }
+    const { slug, title, yaml_content, is_public } = req.body;
+    if (!slug || !yaml_content) {
+      return res.status(400).json({ error: "slug and yaml_content are required" });
+    }
+    try {
+      const listResponse = await fetch(`${apiUrl}/api/demos`, {
+        headers: { "Authorization": `Bearer ${config.token}` }
+      });
+      if (!listResponse.ok) {
+        if (listResponse.status === 401) {
+          return res.status(401).json({ error: "Authentication expired. Run `demoscript login` again." });
+        }
+        throw new Error("Failed to fetch demos");
+      }
+      const demosData = await listResponse.json();
+      const existingDemo = demosData.demos.find((d) => d.slug === slug);
+      let response;
+      if (existingDemo) {
+        response = await fetch(`${apiUrl}/api/demos/${existingDemo.id}`, {
+          method: "PUT",
+          headers: {
+            "Authorization": `Bearer ${config.token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ slug, title, yaml_content, is_public })
+        });
+      } else {
+        response = await fetch(`${apiUrl}/api/demos`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${config.token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ slug, title, yaml_content, is_public })
+        });
+      }
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.error || "Push failed");
+      }
+      res.json({
+        success: true,
+        url: `${apiUrl}/u/${config.username}/${slug}`,
+        updated: !!existingDemo
+      });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Push failed" });
+    }
+  });
   const uiSourcePaths = [
     (0, import_path6.resolve)(__dirname4, "..", "ui"),
     // packages/cli/dist -> packages/ui (bundled)
@@ -43342,37 +44750,21 @@ async function builder(options) {
   const useViteDevServer = (0, import_fs8.existsSync)((0, import_path6.resolve)(uiSourcePath, "vite.config.ts"));
   if (useViteDevServer) {
     const { createServer: createViteServer } = await import("vite");
+    const hmrConfig = host === "0.0.0.0" ? { port: port + 1 } : { port: port + 1, host: host || "localhost" };
     const vite = await createViteServer({
       root: uiSourcePath,
       configFile: (0, import_path6.resolve)(uiSourcePath, "vite.config.ts"),
       server: {
         middlewareMode: true,
-        hmr: {
-          port: port + 1,
-          host: host || "localhost"
-        }
+        hmr: hmrConfig
       },
       appType: "spa"
     });
-    app.get("/builder", async (_req, res) => {
-      const indexPath = (0, import_path6.resolve)(uiSourcePath, "index.html");
-      let html = (0, import_fs8.readFileSync)(indexPath, "utf-8");
-      html = await vite.transformIndexHtml("/builder", html);
-      html = html.replace("</head>", "<script>window.__DEMOSCRIPT_BUILDER__ = true;</script></head>");
-      res.type("html").send(html);
-    });
-    app.get("/builder-embed", async (_req, res) => {
-      const indexPath = (0, import_path6.resolve)(uiSourcePath, "index.html");
-      let html = (0, import_fs8.readFileSync)(indexPath, "utf-8");
-      html = await vite.transformIndexHtml("/builder-embed", html);
-      html = html.replace("</head>", "<script>window.__DEMOSCRIPT_BUILDER__ = true; window.__DEMOSCRIPT_BUILDER_EMBEDDED__ = true;</script></head>");
-      res.type("html").send(html);
-    });
     app.get("/editor", async (_req, res) => {
       const indexPath = (0, import_path6.resolve)(uiSourcePath, "index.html");
       let html = (0, import_fs8.readFileSync)(indexPath, "utf-8");
       html = await vite.transformIndexHtml("/editor", html);
-      html = html.replace("</head>", "<script>window.__DEMOSCRIPT_EDITOR__ = true;</script></head>");
+      html = html.replace("</head>", "<script>window.__DEMOSCRIPT_EDITOR__ = true; window.__DEMOSCRIPT_CLI_MODE__ = true; window.__DEMOSCRIPT_CLOUD_ENABLED__ = true;</script></head>");
       res.type("html").send(html);
     });
     app.get("/editor-embed", async (_req, res) => {
@@ -43388,15 +44780,7 @@ async function builder(options) {
     app.use(vite.middlewares);
   } else if ((0, import_fs8.existsSync)(uiDistPath)) {
     const indexHtml = (0, import_fs8.readFileSync)((0, import_path6.join)(uiDistPath, "index.html"), "utf-8");
-    const injectedHtml = indexHtml.replace("</head>", `<script>window.__DEMOSCRIPT_BUILDER__ = true;</script></head>`);
-    app.get("/builder", (_req, res) => {
-      res.type("html").send(injectedHtml);
-    });
-    const embeddedHtml = indexHtml.replace("</head>", `<script>window.__DEMOSCRIPT_BUILDER__ = true; window.__DEMOSCRIPT_BUILDER_EMBEDDED__ = true;</script></head>`);
-    app.get("/builder-embed", (_req, res) => {
-      res.type("html").send(embeddedHtml);
-    });
-    const editorHtml = indexHtml.replace("</head>", `<script>window.__DEMOSCRIPT_EDITOR__ = true;</script></head>`);
+    const editorHtml = indexHtml.replace("</head>", `<script>window.__DEMOSCRIPT_EDITOR__ = true; window.__DEMOSCRIPT_CLI_MODE__ = true; window.__DEMOSCRIPT_CLOUD_ENABLED__ = true;</script></head>`);
     app.get("/editor", (_req, res) => {
       res.type("html").send(editorHtml);
     });
@@ -43415,10 +44799,9 @@ async function builder(options) {
   const listenHost = host || "localhost";
   const server = app.listen(port, listenHost, async () => {
     console.log();
-    console.log(source_default.green.bold("  DemoScript Builder is running!"));
+    console.log(source_default.green.bold("  DemoScript Visual Editor is running!"));
     console.log();
-    console.log(`  ${source_default.cyan("Editor:")}  http://localhost:${port}/editor ${source_default.gray("(new)")}`);
-    console.log(`  ${source_default.cyan("Builder:")} http://localhost:${port}/builder ${source_default.gray("(legacy)")}`);
+    console.log(`  ${source_default.cyan("Editor:")} http://localhost:${port}/editor`);
     if (host === "0.0.0.0") {
       const networkUrl = getNetworkUrl2(port);
       if (networkUrl) {
@@ -43466,9 +44849,9 @@ program2.command("whoami").description("Show current logged in user").action(asy
 program2.command("push <demo>").description("Push demo to DemoScript Cloud").option("-s, --slug <slug>", "Demo slug (default: directory name)").option("-t, --title <title>", "Demo title (default: from YAML)").option("--public", "Make demo public (default)").option("--private", "Make demo private").action(async (demo, options) => {
   await push(demo, options);
 });
-program2.command("builder").description("Open the visual demo builder").option("-p, --port <port>", "Port to run on", "3002").option("-H, --host [host]", "Host to bind to (use --host for 0.0.0.0)").option("--no-open", "Do not open browser automatically").action(async (options) => {
+program2.command("edit [demo]").description("Open visual demo editor").option("-p, --port <port>", "Port to run editor on", "3002").option("-H, --host [host]", "Host to bind to (use --host for 0.0.0.0)").option("--no-open", "Do not open browser automatically").action(async (demo, options) => {
   const host = options.host === true ? "0.0.0.0" : typeof options.host === "string" ? options.host : void 0;
-  await builder({ port: parseInt(options.port, 10), host, open: options.open });
+  await builder({ port: parseInt(options.port, 10), host, open: options.open, demoPath: demo });
 });
 program2.parse();
 /*! Bundled license information: