@openagentpack/playground 0.3.0 → 0.3.1

package/dist/bin/playground.js

@@ -3,14 +3,14 @@
 // src/server.ts
 import "@hono/zod-openapi";
 import { readFileSync } from "fs";
-import { dirname as dirname3, join as join2 } from "path";
+import { dirname as dirname4, join as join3 } from "path";
 import { fileURLToPath } from "url";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { bootstrapRuntimeCredentials as bootstrapRuntimeCredentials2 } from "@openagentpack/sdk";
 
 // ../../apps/server/src/app.ts
-import { OpenAPIHono as OpenAPIHono13 } from "@hono/zod-openapi";
+import { OpenAPIHono as OpenAPIHono14 } from "@hono/zod-openapi";
 import { cors } from "hono/cors";
 
 // ../../apps/server/src/lib/http-error.ts
@@ -1360,8 +1360,8 @@ var RUNTIME_PROJECT_NAME = "bailian-cli";
 function resolveRuntimeProvider() {
   return process.env.AGENTS_PROVIDER?.trim() || "bailian";
 }
-async function buildRuntimeConfig() {
-  const provider = resolveRuntimeProvider();
+async function buildRuntimeConfig(providerOverride) {
+  const provider = providerOverride?.trim() || resolveRuntimeProvider();
   const providerConfig = resolveProviderConfigFromEnv(provider);
   const environment = getEnvironmentProfile(provider);
   const vault = getVaultProfile(provider);
@@ -1458,8 +1458,8 @@ function createWebUiStateBackend(input = {}) {
 }
 
 // ../../apps/server/src/services/runtime-factory.ts
-async function loadServerRuntimeConfig() {
-  const { configPath, projectName, config } = await buildRuntimeConfig();
+async function loadServerRuntimeConfig(providerOverride) {
+  const { configPath, projectName, config } = await buildRuntimeConfig(providerOverride);
   const stateScope = deriveWebUiStateScope();
   const stateBackend = createWebUiStateBackend();
   const statePath = stateBackend.getStatePath(stateScope);
@@ -1473,8 +1473,8 @@ async function loadServerRuntimeConfig() {
     statePath
   };
 }
-async function loadAgentRuntimeInput(agentId, modelOverride) {
-  const base = await loadServerRuntimeConfig();
+async function loadAgentRuntimeInput(agentId, modelOverride, providerOverride) {
+  const base = await loadServerRuntimeConfig(providerOverride);
   const compiled = compileAgentRuntime(agentId, base.config, modelOverride);
   return {
     ...base,
@@ -1484,6 +1484,9 @@ async function loadAgentRuntimeInput(agentId, modelOverride) {
     compiled
   };
 }
+async function loadCompiledRuntimeInput(agentId, provider) {
+  return loadAgentRuntimeInput(agentId, void 0, provider);
+}
 async function withAgentRuntime(agentId, fn) {
   const input = await loadAgentRuntimeInput(agentId);
   return readProjectRuntime(input, (ctx) => fn(ctx, input.compiled));
@@ -2319,40 +2322,308 @@ configRoute.openapi(saveConfigRoute, async (c) => {
   return c.json(config, 200);
 });
 
+// ../../apps/server/src/routes/deployments.ts
+import { createRoute as createRoute3, OpenAPIHono as OpenAPIHono3, z as z5 } from "@hono/zod-openapi";
+
+// ../../apps/server/src/schemas/deployments.ts
+import { z as z4 } from "@hono/zod-openapi";
+var DeploymentStatusSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  playbookId: z4.string(),
+  provider: z4.string(),
+  prompt: z4.string(),
+  schedule: z4.object({ expression: z4.string(), timezone: z4.string() }),
+  status: z4.string(),
+  remoteId: z4.string().nullable()
+});
+var DeploymentListSchema = z4.object({ deployments: z4.array(DeploymentStatusSchema) });
+var CreateDeploymentBodySchema = z4.object({
+  name: z4.string().min(1),
+  playbookId: z4.string().min(1),
+  prompt: z4.string().min(1),
+  expression: z4.string().min(1),
+  timezone: z4.string().min(1).default("Asia/Shanghai")
+});
+var SetDeploymentPausedBodySchema = z4.object({ paused: z4.boolean() });
+var DeploymentRunSchema = z4.object({
+  name: z4.string(),
+  provider: z4.string(),
+  result: z4.object({
+    run_id: z4.string().optional(),
+    session_id: z4.string().nullable(),
+    error: z4.object({ type: z4.string(), message: z4.string() }).optional()
+  })
+});
+var DeleteDeploymentSchema = z4.object({ deleted: z4.boolean() });
+
+// ../../apps/server/src/services/deployments/manage.ts
+import { mkdir as mkdir2, readFile as readFile2, rename, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join2 } from "path";
+import {
+  executePlannedProject,
+  getDeploymentDetailsForContext,
+  pauseDeploymentForContext,
+  planProjectContext,
+  runDeploymentForContext,
+  syncAgentResourcesWithStateBackend as syncAgentResourcesWithStateBackend3,
+  UserError as UserError3,
+  writeProjectRuntime as writeProjectRuntime2
+} from "@openagentpack/sdk";
+var storePath = () => process.env.AGENTS_DEPLOYMENTS_PATH?.trim() || join2(homedir2(), ".agents", "playground.deployments.json");
+async function readStore() {
+  try {
+    const parsed = JSON.parse(await readFile2(storePath(), "utf8"));
+    return Array.isArray(parsed.deployments) ? parsed.deployments.map((item) => ({
+      ...item,
+      // Legacy records predate provider ownership. The active provider is the only
+      // recoverable source for those records; every new record persists it explicitly.
+      provider: item.provider ?? process.env.AGENTS_PROVIDER
+    })) : [];
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+async function writeStore(deployments) {
+  const path = storePath();
+  await mkdir2(dirname3(path), { recursive: true });
+  const temp = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  await writeFile2(temp, `${JSON.stringify({ deployments }, null, 2)}
+`, { mode: 384 });
+  await rename(temp, path);
+}
+function attachDeployment(input, item) {
+  const config = JSON.parse(JSON.stringify(input.config));
+  config.deployments = {
+    ...config.deployments ?? {},
+    [item.id]: {
+      agent: input.compiled.agentId,
+      environment: Object.keys(config.environments ?? {})[0],
+      initial_events: [{ type: "user.message", content: item.prompt }],
+      schedule: { expression: item.expression, timezone: item.timezone },
+      description: item.name,
+      provider: config.defaults?.provider,
+      metadata: { "openagentpack.webui": "schedule", "openagentpack.title": item.name }
+    }
+  };
+  return { ...input, config, providers: config.providers };
+}
+async function runtimeFor(item) {
+  return attachDeployment(await loadCompiledRuntimeInput(item.playbookId, item.provider), item);
+}
+function assertNativeProvider(provider) {
+  if (provider !== "qoder" && provider !== "claude") {
+    throw new UserError3(
+      `WebUI schedules require a native deployment provider (qoder or claude), got '${provider ?? "unknown"}'.`
+    );
+  }
+}
+async function executeOnlyDeployment(input, id, deleting = false) {
+  return writeProjectRuntime2(input, async (ctx) => {
+    const planned = await planProjectContext(ctx, { provider: input.config.defaults?.provider, quiet: true });
+    const actions = planned.plan.actions.filter(
+      (action) => action.address.type === "deployment" && action.address.name === id && (!deleting || action.action === "delete")
+    );
+    if (actions.length === 0)
+      throw new UserError3(`Deployment '${id}' produced no ${deleting ? "delete" : "apply"} action.`);
+    const execution = await executePlannedProject(
+      {
+        ...planned,
+        plan: { ...planned.plan, actions },
+        destructiveActions: actions.filter((a) => a.action === "delete")
+      },
+      { policy: deleting ? "force" : "block" }
+    );
+    const failed = execution.results.find((result) => result.status !== "success");
+    if (failed) {
+      throw new UserError3(failed.error ?? `Deployment '${id}' ${failed.status}.`);
+    }
+    return execution;
+  });
+}
+var storeMutationQueue = Promise.resolve();
+function serializeStoreMutation(mutation) {
+  const result = storeMutationQueue.then(mutation, mutation);
+  storeMutationQueue = result.then(
+    () => void 0,
+    () => void 0
+  );
+  return result;
+}
+async function listManagedDeployments() {
+  const records = await readStore();
+  return Promise.all(
+    records.map(async (item) => {
+      try {
+        const input = await runtimeFor(item);
+        assertNativeProvider(input.config.defaults?.provider);
+        return await writeProjectRuntime2(input, async (ctx) => {
+          const detail = await getDeploymentDetailsForContext(ctx, item.id);
+          return {
+            ...item,
+            provider: detail.provider,
+            schedule: { expression: item.expression, timezone: item.timezone },
+            status: detail.info.status,
+            remoteId: detail.info.id
+          };
+        });
+      } catch {
+        return {
+          ...item,
+          schedule: { expression: item.expression, timezone: item.timezone },
+          status: "unavailable",
+          remoteId: null
+        };
+      }
+    })
+  );
+}
+async function createManagedDeployment(input) {
+  return serializeStoreMutation(async () => {
+    const records = await readStore();
+    const id = `schedule-${crypto.randomUUID()}`;
+    const base = await loadCompiledRuntimeInput(input.playbookId);
+    assertNativeProvider(base.config.defaults?.provider);
+    const item = { ...input, id, provider: base.config.defaults.provider };
+    const runtime = attachDeployment(base, item);
+    const agentRun = await syncAgentResourcesWithStateBackend3(runtime, runtime.compiled.agentId);
+    if (agentRun.status !== "completed") throw new UserError3(agentRun.error ?? "Failed to provision schedule agent.");
+    await executeOnlyDeployment(runtime, id);
+    await writeStore([...records, item]);
+    return (await listManagedDeployments()).find((deployment) => deployment.id === id);
+  });
+}
+async function requireStored(id) {
+  const records = await readStore();
+  const item = records.find((record) => record.id === id);
+  if (!item) throw new UserError3(`Deployment '${id}' not found.`);
+  return { item, records };
+}
+async function setManagedDeploymentPaused(id, paused) {
+  const { item } = await requireStored(id);
+  const input = await runtimeFor(item);
+  return writeProjectRuntime2(input, (ctx) => pauseDeploymentForContext(ctx, id, paused));
+}
+async function runManagedDeployment(id) {
+  const { item } = await requireStored(id);
+  const input = await runtimeFor(item);
+  const run = await writeProjectRuntime2(input, (ctx) => runDeploymentForContext(ctx, id));
+  if (run.result.error) {
+    throw new UserError3(`Deployment run failed: ${run.result.error.type} - ${run.result.error.message}`);
+  }
+  return run;
+}
+async function deleteManagedDeployment(id) {
+  return serializeStoreMutation(async () => {
+    const { item, records } = await requireStored(id);
+    const input = await runtimeFor(item);
+    input.config.deployments = {};
+    await executeOnlyDeployment(input, id, true);
+    await writeStore(records.filter((record) => record.id !== id));
+    return { deleted: true };
+  });
+}
+
+// ../../apps/server/src/routes/deployments.ts
+var deploymentsRoute = new OpenAPIHono3();
+var idParam = z5.object({ id: z5.string().min(1) });
+var listRoute = createRoute3({
+  method: "get",
+  path: "/deployments",
+  responses: {
+    200: { description: "List managed deployments", content: { "application/json": { schema: DeploymentListSchema } } },
+    ...errorResponses
+  }
+});
+deploymentsRoute.openapi(listRoute, async (c) => c.json({ deployments: await listManagedDeployments() }, 200));
+var createRouteDef = createRoute3({
+  method: "post",
+  path: "/deployments",
+  request: { body: { content: { "application/json": { schema: CreateDeploymentBodySchema } } } },
+  responses: {
+    201: {
+      description: "Create a native deployment",
+      content: { "application/json": { schema: DeploymentStatusSchema } }
+    },
+    ...errorResponses
+  }
+});
+deploymentsRoute.openapi(createRouteDef, async (c) => c.json(await createManagedDeployment(c.req.valid("json")), 201));
+var pauseRoute = createRoute3({
+  method: "put",
+  path: "/deployments/{id}/paused",
+  request: { params: idParam, body: { content: { "application/json": { schema: SetDeploymentPausedBodySchema } } } },
+  responses: {
+    200: {
+      description: "Pause or resume a deployment",
+      content: {
+        "application/json": { schema: z5.object({ id: z5.string().nullable(), status: z5.string() }).passthrough() }
+      }
+    },
+    ...errorResponses
+  }
+});
+deploymentsRoute.openapi(
+  pauseRoute,
+  async (c) => c.json(await setManagedDeploymentPaused(c.req.valid("param").id, c.req.valid("json").paused), 200)
+);
+var runRoute = createRoute3({
+  method: "post",
+  path: "/deployments/{id}/runs",
+  request: { params: idParam },
+  responses: {
+    201: { description: "Trigger a deployment run", content: { "application/json": { schema: DeploymentRunSchema } } },
+    ...errorResponses
+  }
+});
+deploymentsRoute.openapi(runRoute, async (c) => c.json(await runManagedDeployment(c.req.valid("param").id), 201));
+var deleteRoute = createRoute3({
+  method: "delete",
+  path: "/deployments/{id}",
+  request: { params: idParam },
+  responses: {
+    200: { description: "Delete a deployment", content: { "application/json": { schema: DeleteDeploymentSchema } } },
+    ...errorResponses
+  }
+});
+deploymentsRoute.openapi(deleteRoute, async (c) => c.json(await deleteManagedDeployment(c.req.valid("param").id), 200));
+
 // ../../apps/server/src/routes/environments.ts
-import { createRoute as createRoute3, OpenAPIHono as OpenAPIHono3 } from "@hono/zod-openapi";
+import { createRoute as createRoute4, OpenAPIHono as OpenAPIHono4 } from "@hono/zod-openapi";
 import { createCloudEnvironment, deleteCloudEnvironment, listCloudEnvironments } from "@openagentpack/sdk";
 
 // ../../apps/server/src/schemas/environments.ts
-import { z as z4 } from "@hono/zod-openapi";
+import { z as z6 } from "@hono/zod-openapi";
 import { CloudEnvironmentSchema } from "@openagentpack/sdk";
 import { CloudEnvironmentSchema as CloudEnvironmentSchema2 } from "@openagentpack/sdk";
-var CloudEnvironmentsResponseSchema = z4.object({
-  environments: z4.array(CloudEnvironmentSchema)
-});
-var CreateEnvironmentBodySchema = z4.object({
-  name: z4.string().min(1),
-  description: z4.string().optional(),
-  metadata: z4.record(z4.string(), z4.string()).optional()
-});
-var CreateEnvironmentResponseSchema = z4.object({
-  environment: z4.object({
-    id: z4.string().nullable(),
-    type: z4.string(),
-    version: z4.number().optional()
+var CloudEnvironmentsResponseSchema = z6.object({
+  environments: z6.array(CloudEnvironmentSchema)
+});
+var CreateEnvironmentBodySchema = z6.object({
+  name: z6.string().min(1),
+  description: z6.string().optional(),
+  metadata: z6.record(z6.string(), z6.string()).optional()
+});
+var CreateEnvironmentResponseSchema = z6.object({
+  environment: z6.object({
+    id: z6.string().nullable(),
+    type: z6.string(),
+    version: z6.number().optional()
   })
 });
-var DeleteEnvironmentResponseSchema = z4.object({
-  id: z4.string(),
-  type: z4.string()
+var DeleteEnvironmentResponseSchema = z6.object({
+  id: z6.string(),
+  type: z6.string()
 });
-var EnvironmentParamsSchema = z4.object({
-  environmentId: z4.string().min(1)
+var EnvironmentParamsSchema = z6.object({
+  environmentId: z6.string().min(1)
 });
 
 // ../../apps/server/src/routes/environments.ts
-var environmentsRoute = new OpenAPIHono3();
-var listEnvironmentsRoute = createRoute3({
+var environmentsRoute = new OpenAPIHono4();
+var listEnvironmentsRoute = createRoute4({
   method: "get",
   path: "/environments",
   responses: {
@@ -2367,7 +2638,7 @@ environmentsRoute.openapi(listEnvironmentsRoute, async (c) => {
   const environments = await withAgentRuntime(DEFAULT_AGENT_ID, (ctx) => listCloudEnvironments(ctx));
   return c.json({ environments }, 200);
 });
-var createEnvironmentRoute = createRoute3({
+var createEnvironmentRoute = createRoute4({
   method: "post",
   path: "/environments",
   request: {
@@ -2396,7 +2667,7 @@ environmentsRoute.openapi(createEnvironmentRoute, async (c) => {
   );
   return c.json({ environment }, 200);
 });
-var deleteEnvironmentRoute = createRoute3({
+var deleteEnvironmentRoute = createRoute4({
   method: "delete",
   path: "/environments/{environmentId}",
   request: {
@@ -2417,44 +2688,44 @@ environmentsRoute.openapi(deleteEnvironmentRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/files.ts
-import { createRoute as createRoute4, OpenAPIHono as OpenAPIHono4 } from "@hono/zod-openapi";
+import { createRoute as createRoute5, OpenAPIHono as OpenAPIHono5 } from "@hono/zod-openapi";
 
 // ../../apps/server/src/schemas/files.ts
-import { z as z5 } from "@hono/zod-openapi";
-var ProviderFileInfoSchema = z5.object({
-  id: z5.string(),
-  filename: z5.string(),
-  mime_type: z5.string(),
-  size_bytes: z5.number(),
-  created_at: z5.string(),
-  downloadable: z5.boolean().optional(),
-  status: z5.string().optional(),
-  purpose: z5.string().optional(),
-  available: z5.boolean().optional()
+import { z as z7 } from "@hono/zod-openapi";
+var ProviderFileInfoSchema = z7.object({
+  id: z7.string(),
+  filename: z7.string(),
+  mime_type: z7.string(),
+  size_bytes: z7.number(),
+  created_at: z7.string(),
+  downloadable: z7.boolean().optional(),
+  status: z7.string().optional(),
+  purpose: z7.string().optional(),
+  available: z7.boolean().optional()
 }).openapi("ProviderFileInfo");
-var UploadFileFormSchema = z5.object({
-  file: z5.instanceof(File).openapi({ type: "string", format: "binary" })
+var UploadFileFormSchema = z7.object({
+  file: z7.instanceof(File).openapi({ type: "string", format: "binary" })
 });
-var FilesResponseSchema = z5.object({
-  files: z5.array(ProviderFileInfoSchema)
+var FilesResponseSchema = z7.object({
+  files: z7.array(ProviderFileInfoSchema)
 });
-var FileStatusesBodySchema = z5.object({
-  fileIds: z5.array(z5.string())
+var FileStatusesBodySchema = z7.object({
+  fileIds: z7.array(z7.string())
 });
-var FileStatusInfoSchema = z5.object({
-  id: z5.string(),
-  status: z5.string().optional(),
-  available: z5.boolean().optional()
+var FileStatusInfoSchema = z7.object({
+  id: z7.string(),
+  status: z7.string().optional(),
+  available: z7.boolean().optional()
 });
-var FileStatusesResponseSchema = z5.object({
-  files: z5.array(FileStatusInfoSchema)
+var FileStatusesResponseSchema = z7.object({
+  files: z7.array(FileStatusInfoSchema)
 });
-var FileParamsSchema = z5.object({
-  id: z5.string().min(1)
+var FileParamsSchema = z7.object({
+  id: z7.string().min(1)
 });
-var FileDownloadResponseSchema = z5.object({
-  url: z5.string(),
-  expires_at: z5.string().optional()
+var FileDownloadResponseSchema = z7.object({
+  url: z7.string(),
+  expires_at: z7.string().optional()
 });
 
 // ../../apps/server/src/services/files/upload.ts
@@ -2507,9 +2778,9 @@ async function getUserFileStatuses(fileIds) {
 }
 
 // ../../apps/server/src/routes/files.ts
-var filesRoute = new OpenAPIHono4();
+var filesRoute = new OpenAPIHono5();
 var MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
-var uploadFileRoute = createRoute4({
+var uploadFileRoute = createRoute5({
   method: "post",
   path: "/files",
   operationId: "uploadFile",
@@ -2553,7 +2824,7 @@ filesRoute.openapi(
     if (!result.success) return c.json({ error: { message: "file is required" } }, 400);
   }
 );
-var listFilesRoute = createRoute4({
+var listFilesRoute = createRoute5({
   method: "get",
   path: "/files",
   operationId: "listFiles",
@@ -2569,7 +2840,7 @@ filesRoute.openapi(listFilesRoute, async (c) => {
   const files = await listUserFiles();
   return c.json({ files }, 200);
 });
-var getFileStatusesRoute = createRoute4({
+var getFileStatusesRoute = createRoute5({
   method: "post",
   path: "/files/status",
   operationId: "getFileStatuses",
@@ -2598,7 +2869,7 @@ filesRoute.openapi(
     if (!result.success) return c.json({ error: { message: "fileIds (string[]) is required" } }, 400);
   }
 );
-var downloadFileRoute = createRoute4({
+var downloadFileRoute = createRoute5({
   method: "get",
   path: "/files/{id}/download",
   operationId: "downloadFile",
@@ -2616,7 +2887,7 @@ filesRoute.openapi(downloadFileRoute, async (c) => {
   const result = await getUserFileDownloadUrl(id);
   return c.json(result, 200);
 });
-var deleteFileRoute = createRoute4({
+var deleteFileRoute = createRoute5({
   method: "delete",
   path: "/files/{id}",
   operationId: "deleteFile",
@@ -2633,24 +2904,24 @@ filesRoute.openapi(deleteFileRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/models.ts
-import { createRoute as createRoute5, OpenAPIHono as OpenAPIHono5 } from "@hono/zod-openapi";
+import { createRoute as createRoute6, OpenAPIHono as OpenAPIHono6 } from "@hono/zod-openapi";
 import { listProviderModelsForContext } from "@openagentpack/sdk";
 
 // ../../apps/server/src/schemas/models.ts
-import { z as z6 } from "@hono/zod-openapi";
-var ModelOptionSchema = z6.object({
-  id: z6.string(),
-  display_name: z6.string(),
-  is_enabled: z6.boolean().optional(),
-  is_new: z6.boolean().optional()
+import { z as z8 } from "@hono/zod-openapi";
+var ModelOptionSchema = z8.object({
+  id: z8.string(),
+  display_name: z8.string(),
+  is_enabled: z8.boolean().optional(),
+  is_new: z8.boolean().optional()
 });
-var ModelsResponseSchema = z6.object({
-  models: z6.array(ModelOptionSchema)
+var ModelsResponseSchema = z8.object({
+  models: z8.array(ModelOptionSchema)
 });
 
 // ../../apps/server/src/routes/models.ts
-var modelsRoute = new OpenAPIHono5();
-var listModelsRoute = createRoute5({
+var modelsRoute = new OpenAPIHono6();
+var listModelsRoute = createRoute6({
   method: "get",
   path: "/models",
   responses: {
@@ -2678,72 +2949,72 @@ modelsRoute.openapi(listModelsRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/sessions/index.ts
-import { createRoute as createRoute10, OpenAPIHono as OpenAPIHono10 } from "@hono/zod-openapi";
+import { createRoute as createRoute11, OpenAPIHono as OpenAPIHono11 } from "@hono/zod-openapi";
 
 // ../../apps/server/src/schemas/sessions.ts
-import { z as z7 } from "@hono/zod-openapi";
+import { z as z9 } from "@hono/zod-openapi";
 import { SessionEventSchema, SessionSchema } from "@openagentpack/sdk";
-var SessionListResponseSchema = z7.object({
-  data: z7.array(SessionSchema),
-  next_page_token: z7.string().nullish()
+var SessionListResponseSchema = z9.object({
+  data: z9.array(SessionSchema),
+  next_page_token: z9.string().nullish()
 }).openapi("SessionListResponse");
-var SessionDetailResponseSchema = z7.object({
+var SessionDetailResponseSchema = z9.object({
   session: SessionSchema,
-  events: z7.array(SessionEventSchema),
-  events_next_page_token: z7.string().nullish()
+  events: z9.array(SessionEventSchema),
+  events_next_page_token: z9.string().nullish()
 }).openapi("SessionDetailResponse");
-var SessionEventsPageResponseSchema = z7.object({
-  events: z7.array(SessionEventSchema),
-  events_next_page_token: z7.string().nullish()
+var SessionEventsPageResponseSchema = z9.object({
+  events: z9.array(SessionEventSchema),
+  events_next_page_token: z9.string().nullish()
 }).openapi("SessionEventsPageResponse");
-var SessionDeleteResponseSchema = z7.object({
-  session_id: z7.string(),
-  deleted: z7.boolean()
+var SessionDeleteResponseSchema = z9.object({
+  session_id: z9.string(),
+  deleted: z9.boolean()
 }).openapi("SessionDeleteResponse");
-var SessionsQuerySchema = z7.object({
+var SessionsQuerySchema = z9.object({
   // Non-numeric values resolve to `undefined` so the handler clamps to a
   // default instead of the request being rejected with a 400.
-  limit: z7.preprocess((value) => {
+  limit: z9.preprocess((value) => {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : void 0;
-  }, z7.number().int().optional()),
-  agentId: z7.string().optional(),
+  }, z9.number().int().optional()),
+  agentId: z9.string().optional(),
   // Opaque cursor for the next page (provider's next_page / next_page_token, passed through verbatim).
-  pageToken: z7.string().optional()
+  pageToken: z9.string().optional()
 });
-var SessionDetailQuerySchema = z7.object({
-  agentId: z7.string().optional()
+var SessionDetailQuerySchema = z9.object({
+  agentId: z9.string().optional()
 });
-var SessionEventsQuerySchema = z7.object({
-  agentId: z7.string().optional(),
-  pageToken: z7.string().optional(),
-  limit: z7.preprocess((value) => {
+var SessionEventsQuerySchema = z9.object({
+  agentId: z9.string().optional(),
+  pageToken: z9.string().optional(),
+  limit: z9.preprocess((value) => {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : void 0;
-  }, z7.number().int().optional())
+  }, z9.number().int().optional())
 });
-var SessionParamsSchema = z7.object({
-  sessionId: z7.string()
+var SessionParamsSchema = z9.object({
+  sessionId: z9.string()
 });
-var CreateSessionBodySchema = z7.object({
-  agentId: z7.string(),
-  prompt: z7.string().min(1),
+var CreateSessionBodySchema = z9.object({
+  agentId: z9.string(),
+  prompt: z9.string().min(1),
   // Required: a session must be pinned to a cloud environment (sandbox).
-  environmentId: z7.string().min(1),
+  environmentId: z9.string().min(1),
   // Optional: cloud vault ids to bind a user-supplied credential so the sandbox receives it.
   // Top-level binding shape matches the console createSession.
-  vaultIds: z7.array(z7.string()).optional(),
-  title: z7.string().optional(),
+  vaultIds: z9.array(z9.string()).optional(),
+  title: z9.string().optional(),
   // Uploaded files to mount as session resources so the task can read the user's files.
   // Each file needs a mount_path (provider rejects a file resource without one).
-  files: z7.array(z7.object({ fileId: z7.string(), mountPath: z7.string() })).optional(),
+  files: z9.array(z9.object({ fileId: z9.string(), mountPath: z9.string() })).optional(),
   // Model the agent should run for this session. If present, createSession applies it
   // to the agent config immediately before starting the run.
-  model: z7.string().optional()
+  model: z9.string().optional()
 });
-var SendMessageBodySchema = z7.object({
-  agentId: z7.string().optional(),
-  message: z7.string().min(1)
+var SendMessageBodySchema = z9.object({
+  agentId: z9.string().optional(),
+  message: z9.string().min(1)
 });
 
 // ../../apps/server/src/services/sessions/event-sanitizer.ts
@@ -2754,9 +3025,9 @@ function shouldIncludeDebugRaw(request) {
 }
 
 // ../../apps/server/src/routes/sessions/detail.ts
-import { createRoute as createRoute6, OpenAPIHono as OpenAPIHono6 } from "@hono/zod-openapi";
-var sessionsDetailRoute = new OpenAPIHono6();
-var getSessionRoute = createRoute6({
+import { createRoute as createRoute7, OpenAPIHono as OpenAPIHono7 } from "@hono/zod-openapi";
+var sessionsDetailRoute = new OpenAPIHono7();
+var getSessionRoute = createRoute7({
   method: "get",
   path: "/sessions/{sessionId}",
   request: {
@@ -2785,7 +3056,7 @@ sessionsDetailRoute.openapi(getSessionRoute, async (c) => {
     200
   );
 });
-var deleteSessionRoute = createRoute6({
+var deleteSessionRoute = createRoute7({
   method: "delete",
   path: "/sessions/{sessionId}",
   request: {
@@ -2808,9 +3079,9 @@ sessionsDetailRoute.openapi(deleteSessionRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/sessions/events.ts
-import { createRoute as createRoute7, OpenAPIHono as OpenAPIHono7 } from "@hono/zod-openapi";
-var sessionsEventsRoute = new OpenAPIHono7();
-var listSessionEventsRoute = createRoute7({
+import { createRoute as createRoute8, OpenAPIHono as OpenAPIHono8 } from "@hono/zod-openapi";
+var sessionsEventsRoute = new OpenAPIHono8();
+var listSessionEventsRoute = createRoute8({
   method: "get",
   path: "/sessions/{sessionId}/events",
   request: {
@@ -2847,9 +3118,9 @@ sessionsEventsRoute.openapi(listSessionEventsRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/sessions/messages.ts
-import { createRoute as createRoute8, OpenAPIHono as OpenAPIHono8 } from "@hono/zod-openapi";
-var sessionsMessagesRoute = new OpenAPIHono8();
-var sendMessageRoute = createRoute8({
+import { createRoute as createRoute9, OpenAPIHono as OpenAPIHono9 } from "@hono/zod-openapi";
+var sessionsMessagesRoute = new OpenAPIHono9();
+var sendMessageRoute = createRoute9({
   method: "post",
   path: "/sessions/{sessionId}/messages",
   request: {
@@ -2878,15 +3149,15 @@ sessionsMessagesRoute.openapi(sendMessageRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/sessions/stream.ts
-import { createRoute as createRoute9, OpenAPIHono as OpenAPIHono9, z as z8 } from "@hono/zod-openapi";
-var sessionsStreamRoute = new OpenAPIHono9();
-var SessionStreamQuerySchema = z8.object({
-  after: z8.preprocess((value) => {
+import { createRoute as createRoute10, OpenAPIHono as OpenAPIHono10, z as z10 } from "@hono/zod-openapi";
+var sessionsStreamRoute = new OpenAPIHono10();
+var SessionStreamQuerySchema = z10.object({
+  after: z10.preprocess((value) => {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : void 0;
-  }, z8.number().int().optional())
+  }, z10.number().int().optional())
 });
-var streamSessionRoute = createRoute9({
+var streamSessionRoute = createRoute10({
   method: "get",
   path: "/sessions/{sessionId}/stream",
   request: {
@@ -2898,7 +3169,7 @@ var streamSessionRoute = createRoute9({
       description: "Stream session events as Server-Sent Events",
       content: {
         "text/event-stream": {
-          schema: z8.string().openapi({
+          schema: z10.string().openapi({
             description: 'SSE frames with event types "event", "done", and "ping".'
           })
         }
@@ -3008,8 +3279,8 @@ data: ${data}
 }
 
 // ../../apps/server/src/routes/sessions/index.ts
-var sessionsRoute = new OpenAPIHono10();
-var listSessionsRoute = createRoute10({
+var sessionsRoute = new OpenAPIHono11();
+var listSessionsRoute = createRoute11({
   method: "get",
   path: "/sessions",
   request: {
@@ -3035,7 +3306,7 @@ sessionsRoute.openapi(listSessionsRoute, async (c) => {
   });
   return c.json({ data: sessions, next_page_token: nextPageToken ?? null }, 200);
 });
-var createSessionRoute = createRoute10({
+var createSessionRoute = createRoute11({
   method: "post",
   path: "/sessions",
   request: {
@@ -3077,51 +3348,51 @@ sessionsRoute.route("/", sessionsMessagesRoute);
 sessionsRoute.route("/", sessionsStreamRoute);
 
 // ../../apps/server/src/routes/skills.ts
-import { createRoute as createRoute11, OpenAPIHono as OpenAPIHono11 } from "@hono/zod-openapi";
+import { createRoute as createRoute12, OpenAPIHono as OpenAPIHono12 } from "@hono/zod-openapi";
 
 // ../../apps/server/src/schemas/skills.ts
-import { z as z9 } from "@hono/zod-openapi";
-var ProviderSkillInfoSchema = z9.object({
-  id: z9.string(),
-  name: z9.string(),
-  description: z9.string().optional(),
-  source: z9.enum(["custom", "official"]),
-  status: z9.enum(["checking", "active", "rejected", "deleted"]),
-  latest_version: z9.string().optional(),
-  created_at: z9.string().optional(),
-  updated_at: z9.string().optional()
+import { z as z11 } from "@hono/zod-openapi";
+var ProviderSkillInfoSchema = z11.object({
+  id: z11.string(),
+  name: z11.string(),
+  description: z11.string().optional(),
+  source: z11.enum(["custom", "official"]),
+  status: z11.enum(["checking", "active", "rejected", "deleted"]),
+  latest_version: z11.string().optional(),
+  created_at: z11.string().optional(),
+  updated_at: z11.string().optional()
 }).openapi("ProviderSkillInfo");
-var UploadSkillFileFormSchema = z9.object({
-  file: z9.instanceof(File).openapi({ type: "string", format: "binary" })
+var UploadSkillFileFormSchema = z11.object({
+  file: z11.instanceof(File).openapi({ type: "string", format: "binary" })
 });
-var CreateSkillBodySchema = z9.object({
-  fileId: z9.string().min(1)
+var CreateSkillBodySchema = z11.object({
+  fileId: z11.string().min(1)
 });
-var WarmSkillBodySchema = z9.object({
-  name: z9.string().min(1),
-  url: z9.string().min(1)
+var WarmSkillBodySchema = z11.object({
+  name: z11.string().min(1),
+  url: z11.string().min(1)
 });
-var WarmSkillResponseSchema = z9.object({
-  ok: z9.literal(true)
+var WarmSkillResponseSchema = z11.object({
+  ok: z11.literal(true)
 });
-var SkillsQuerySchema = z9.object({
-  source: z9.enum(["custom", "official"]).optional()
+var SkillsQuerySchema = z11.object({
+  source: z11.enum(["custom", "official"]).optional()
 });
-var SkillsResponseSchema = z9.object({
-  skills: z9.array(ProviderSkillInfoSchema)
+var SkillsResponseSchema = z11.object({
+  skills: z11.array(ProviderSkillInfoSchema)
 });
-var SkillStatusesBodySchema = z9.object({
-  skillIds: z9.array(z9.string())
+var SkillStatusesBodySchema = z11.object({
+  skillIds: z11.array(z11.string())
 });
-var SkillStatusInfoSchema = z9.object({
-  id: z9.string(),
-  status: z9.enum(["checking", "active", "rejected", "deleted"]).optional()
+var SkillStatusInfoSchema = z11.object({
+  id: z11.string(),
+  status: z11.enum(["checking", "active", "rejected", "deleted"]).optional()
 });
-var SkillStatusesResponseSchema = z9.object({
-  skills: z9.array(SkillStatusInfoSchema)
+var SkillStatusesResponseSchema = z11.object({
+  skills: z11.array(SkillStatusInfoSchema)
 });
-var SkillParamsSchema = z9.object({
-  id: z9.string().min(1)
+var SkillParamsSchema = z11.object({
+  id: z11.string().min(1)
 });
 
 // ../../apps/server/src/services/skills/manage.ts
@@ -3222,9 +3493,9 @@ async function warmSkillByUrl(name, url) {
 }
 
 // ../../apps/server/src/routes/skills.ts
-var skillsRoute = new OpenAPIHono11();
+var skillsRoute = new OpenAPIHono12();
 var MAX_UPLOAD_BYTES2 = 100 * 1024 * 1024;
-var uploadSkillFileRoute = createRoute11({
+var uploadSkillFileRoute = createRoute12({
   method: "post",
   path: "/skills/upload-file",
   operationId: "uploadSkillFile",
@@ -3263,7 +3534,7 @@ skillsRoute.openapi(
     if (!result.success) return c.json({ error: { message: "file is required" } }, 400);
   }
 );
-var createSkillRoute = createRoute11({
+var createSkillRoute = createRoute12({
   method: "post",
   path: "/skills",
   operationId: "createSkill",
@@ -3292,7 +3563,7 @@ skillsRoute.openapi(
     if (!result.success) return c.json({ error: { message: "fileId is required" } }, 400);
   }
 );
-var warmSkillRoute = createRoute11({
+var warmSkillRoute = createRoute12({
   method: "post",
   path: "/skills/warm",
   operationId: "warmSkill",
@@ -3321,7 +3592,7 @@ skillsRoute.openapi(
     if (!result.success) return c.json({ error: { message: "name and url are required" } }, 400);
   }
 );
-var listSkillsRoute = createRoute11({
+var listSkillsRoute = createRoute12({
   method: "get",
   path: "/skills",
   operationId: "listSkills",
@@ -3347,7 +3618,7 @@ skillsRoute.openapi(
     }
   }
 );
-var getSkillStatusesRoute = createRoute11({
+var getSkillStatusesRoute = createRoute12({
   method: "post",
   path: "/skills/status",
   operationId: "getSkillStatuses",
@@ -3376,7 +3647,7 @@ skillsRoute.openapi(
     if (!result.success) return c.json({ error: { message: "skillIds (string[]) is required" } }, 400);
   }
 );
-var deleteSkillRoute = createRoute11({
+var deleteSkillRoute = createRoute12({
   method: "delete",
   path: "/skills/{id}",
   operationId: "deleteSkill",
@@ -3393,39 +3664,39 @@ skillsRoute.openapi(deleteSkillRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/vaults.ts
-import { createRoute as createRoute12, OpenAPIHono as OpenAPIHono12 } from "@hono/zod-openapi";
+import { createRoute as createRoute13, OpenAPIHono as OpenAPIHono13 } from "@hono/zod-openapi";
 import { createCloudVault, deleteCloudVault, listCloudVaults } from "@openagentpack/sdk";
 
 // ../../apps/server/src/schemas/vaults.ts
-import { z as z10 } from "@hono/zod-openapi";
+import { z as z12 } from "@hono/zod-openapi";
 import { CloudVaultSchema } from "@openagentpack/sdk";
 import { CloudVaultSchema as CloudVaultSchema2 } from "@openagentpack/sdk";
-var CloudVaultsResponseSchema = z10.object({
-  vaults: z10.array(CloudVaultSchema)
+var CloudVaultsResponseSchema = z12.object({
+  vaults: z12.array(CloudVaultSchema)
 });
-var CreateVaultBodySchema = z10.object({
-  name: z10.string().min(1),
-  metadata: z10.record(z10.string(), z10.string()).optional(),
+var CreateVaultBodySchema = z12.object({
+  name: z12.string().min(1),
+  metadata: z12.record(z12.string(), z12.string()).optional(),
   // The DASHSCOPE_API_KEY stored as the vault's credential secret value. Optional:
   // when omitted the server injects it from its own DASHSCOPE_API_KEY env.
-  key: z10.string().min(1).optional()
+  key: z12.string().min(1).optional()
 });
-var CreateVaultResponseSchema = z10.object({
-  id: z10.string().nullable(),
-  type: z10.string(),
-  version: z10.number().optional()
+var CreateVaultResponseSchema = z12.object({
+  id: z12.string().nullable(),
+  type: z12.string(),
+  version: z12.number().optional()
 });
-var DeleteVaultResponseSchema = z10.object({
-  id: z10.string(),
-  type: z10.string()
+var DeleteVaultResponseSchema = z12.object({
+  id: z12.string(),
+  type: z12.string()
 });
-var VaultParamsSchema = z10.object({
-  vaultId: z10.string().min(1)
+var VaultParamsSchema = z12.object({
+  vaultId: z12.string().min(1)
 });
 
 // ../../apps/server/src/routes/vaults.ts
-var vaultsRoute = new OpenAPIHono12();
-var listVaultsRoute = createRoute12({
+var vaultsRoute = new OpenAPIHono13();
+var listVaultsRoute = createRoute13({
   method: "get",
   path: "/vaults",
   responses: {
@@ -3440,7 +3711,7 @@ vaultsRoute.openapi(listVaultsRoute, async (c) => {
   const vaults = await withAgentRuntime(DEFAULT_AGENT_ID, (ctx) => listCloudVaults(ctx));
   return c.json({ vaults }, 200);
 });
-var createVaultRoute = createRoute12({
+var createVaultRoute = createRoute13({
   method: "post",
   path: "/vaults",
   request: {
@@ -3483,7 +3754,7 @@ vaultsRoute.openapi(createVaultRoute, async (c) => {
   );
   return c.json(vault, 200);
 });
-var deleteVaultRoute = createRoute12({
+var deleteVaultRoute = createRoute13({
   method: "delete",
   path: "/vaults/{vaultId}",
   request: {
@@ -3511,7 +3782,7 @@ function requireEnv2(name) {
 }
 
 // ../../apps/server/src/app.ts
-var app = new OpenAPIHono13();
+var app = new OpenAPIHono14();
 app.use(
   "/*",
   cors({
@@ -3522,6 +3793,7 @@ app.use(
   })
 );
 app.route("/api", configRoute);
+app.route("/api", deploymentsRoute);
 app.route("/api", agentsRoute);
 app.route("/api", environmentsRoute);
 app.route("/api", vaultsRoute);
@@ -3569,8 +3841,18 @@ async function resolveListenPort(preferred, maxAttempts = MAX_PORT_ATTEMPTS) {
 
 // src/server.ts
 var DEFAULT_PLAYGROUND_PORT = 4848;
-var webRoot = join2(dirname3(fileURLToPath(import.meta.url)), "../../web");
-var indexHtml = injectPlaygroundRuntimeMarker(readFileSync(join2(webRoot, "index.html"), "utf8"));
+var pkgRoot = join3(dirname4(fileURLToPath(import.meta.url)), "../..");
+var webRoot = join3(pkgRoot, "web");
+var indexHtml = injectPlaygroundRuntimeMarker(readFileSync(join3(webRoot, "index.html"), "utf8"));
+function readPlaygroundVersion() {
+  try {
+    const manifest = JSON.parse(readFileSync(join3(pkgRoot, "package.json"), "utf8"));
+    return manifest.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var playgroundVersion = readPlaygroundVersion();
 function injectPlaygroundRuntimeMarker(html) {
   if (html.includes('name="agents-runtime"')) return html;
   return html.replace("<head>", '<head>\n    <meta name="agents-runtime" content="playground" />');
@@ -3587,9 +3869,14 @@ async function startServer() {
     console.log(`Port ${preferred} is in use, using ${port} instead.`);
   }
   const root = new Hono();
+  root.get("/health", (c) => c.json({ status: "ok", playground: { version: playgroundVersion, pid: process.pid } }));
   root.route("/", app);
   root.get("/", (c) => c.html(indexHtml));
   root.get("/index.html", (c) => c.html(indexHtml));
+  root.use("/assets/*", async (c, next) => {
+    await next();
+    c.header("Cache-Control", "no-cache");
+  });
   root.use("/assets/*", serveStatic({ root: webRoot }));
   root.get("*", (c) => c.html(indexHtml));
   serve({ fetch: root.fetch, port }, () => {