@moondeck/station 0.0.1 → 1.0.1

package/src/ui/types.ts

@@ -0,0 +1,173 @@
+/**
+ * Zod schemas for every local JSON API response (ADR-028, docs/host-ui.md).
+ *
+ * The server parses each response body through these before sending, so the
+ * API can never emit an off-contract shape. This file is the single source of
+ * truth for the wire shapes; the static UI assumes them.
+ */
+
+import { z } from "zod";
+
+const RuntimePreference = z.enum(["auto", "docker", "apple-container"]);
+export const ContainerRuntimeResponse = z.union([
+  z
+    .object({
+      status: z.literal("checking"),
+      preference: RuntimePreference,
+      detail: z.string().trim().min(1).max(300).optional(),
+    })
+    .strict(),
+  z.union([
+    z
+      .object({
+        status: z.literal("ready"),
+        preference: z.enum(["auto", "docker"]),
+        provider: z.literal("docker"),
+      })
+      .strict(),
+    z
+      .object({
+        status: z.literal("ready"),
+        preference: z.enum(["auto", "apple-container"]),
+        provider: z.literal("apple-container"),
+      })
+      .strict(),
+  ]),
+  z
+    .object({
+      status: z.literal("no-runtime"),
+      preference: RuntimePreference,
+      message: z.string().trim().min(1).max(1_000),
+      action: z.string().trim().min(1).max(200),
+    })
+    .strict(),
+]);
+export type ContainerRuntimeResponse = z.infer<typeof ContainerRuntimeResponse>;
+
+// GET /api/status — process + config facts.
+export const StatusResponse = z.object({
+  pid: z.number().int(),
+  uptime: z.number(), // seconds, process.uptime()
+  version: z.string(), // @runuai/host package version
+  logPath: z.string(), // service log file path (per-OS)
+  cloudUrl: z.string(), // UAI_CLOUD_URL
+  hostName: z.string(), // os.hostname()
+  hostId: z.string(), // UAI_HOST_ID
+  // Which agent adapters this host runs (UAI_AGENTS). Optional: a newer CLI
+  // can query a service that is still on the pre-upgrade build, which had no
+  // such field — `npm i -g` swaps the CLI before `uai-host restart` swaps the
+  // service, so that window is normal, not exotic.
+  agentMode: z.enum(["real", "mock"]).optional(),
+  containerRuntime: ContainerRuntimeResponse.optional(),
+  // The package that answers: "@moondeck/station". The frozen @runuai/host
+  // never reports it, so its presence alone says "a station" (legacy-host.ts:
+  // a station must never be taken for the old host on a shared port).
+  product: z.string().optional(),
+});
+export type StatusResponse = z.infer<typeof StatusResponse>;
+
+// GET /api/cloud — live WSS connection state (in-memory, from the bridge).
+export const CloudResponse = z.object({
+  state: z.enum(["connected", "reconnecting", "disconnected"]),
+  lastConnectedAt: z.number().nullable(), // epoch ms
+  reconnectCount: z.number().int(),
+  lastError: z.string().nullable(),
+});
+export type CloudResponse = z.infer<typeof CloudResponse>;
+
+// One active task. Runtime fields come from host.sqlite; owner/slugs are
+// persisted at task-up; memory is best-effort docker.
+export const TaskRow = z.object({
+  taskId: z.string(),
+  status: z.string().nullable(), // statusMirror
+  ownerEmail: z.string().nullable(),
+  projectSlugs: z.array(z.string()),
+  startedAt: z.number().nullable(), // epoch ms
+  ageMs: z.number().nullable(), // now - startedAt
+  composeProject: z.string().nullable(),
+  codeServerPort: z.number().int().nullable(),
+  previewPorts: z.array(
+    z.object({ name: z.string(), hostPort: z.number().int().nullable() }),
+  ),
+  memoryBytes: z.number().nullable(), // docker stats, null on failure
+});
+export type TaskRow = z.infer<typeof TaskRow>;
+
+export const TasksResponse = z.object({ tasks: z.array(TaskRow) });
+export type TasksResponse = z.infer<typeof TasksResponse>;
+
+// GET /api/events — last 50 host-recorded lifecycle events, newest first.
+export const EventRow = z.object({
+  id: z.string(),
+  taskId: z.string(),
+  kind: z.enum(["task.created", "task.started", "task.ended", "task.ship"]),
+  ts: z.number(), // epoch ms
+  detail: z.string().nullable(),
+});
+export type EventRow = z.infer<typeof EventRow>;
+
+export const EventsResponse = z.object({ events: z.array(EventRow) });
+export type EventsResponse = z.infer<typeof EventsResponse>;
+
+// GET /api/users — distinct owners across active tasks. v1: the single operator.
+export const UserRow = z.object({
+  userId: z.string(),
+  email: z.string().nullable(),
+  activeTasks: z.number().int(),
+});
+export type UserRow = z.infer<typeof UserRow>;
+
+export const UsersResponse = z.object({ users: z.array(UserRow) });
+export type UsersResponse = z.infer<typeof UsersResponse>;
+
+// GET /api/engines — the engine catalog + which are connected on this host.
+export const EngineCatalogEntry = z.object({
+  kind: z.enum(["claude", "codex", "kimi", "grok", "cursor", "opencode"]),
+  label: z.string(),
+  authMode: z.enum([
+    "token-command",
+    "login-command",
+    "api-key",
+    "external-login",
+  ]),
+  notes: z.string().nullable(),
+  getKeyUrl: z.string().nullable(),
+  // Pasted-API-key alternative to the login/token flow (null = not offered).
+  apiKeyHint: z.string().nullable(),
+  apiKeyUrl: z.string().nullable(),
+  // Install command shown when the CLI is missing (null = nothing to install).
+  installHint: z.string().nullable(),
+  // external-login: the command the owner runs in their terminal (null else).
+  loginCmd: z.string().nullable(),
+});
+export type EngineCatalogEntry = z.infer<typeof EngineCatalogEntry>;
+
+// One engine account (ADR-076) — secret-free descriptor for the host UI.
+export const EngineAccountInfo = z.object({
+  id: z.string(),
+  kind: z.string(),
+  label: z.string(),
+  authKind: z.enum(["env", "config-dir"]),
+  isDefault: z.boolean(),
+});
+export type EngineAccountInfo = z.infer<typeof EngineAccountInfo>;
+
+export const EnginesResponse = z.object({
+  catalog: z.array(EngineCatalogEntry),
+  statuses: z.record(z.boolean()), // kind → connected
+  cli: z.record(z.boolean()), // kind → CLI resolvable on this host
+  // kind → its accounts (default + extras), ADR-076. Kinds with no account
+  // model (kimi/grok/cursor) are absent.
+  accounts: z.record(z.array(EngineAccountInfo)),
+});
+export type EnginesResponse = z.infer<typeof EnginesResponse>;
+
+// POST /api/engines/disconnect — the disconnect result.
+export const EngineOpResponse = z.object({
+  ok: z.boolean(),
+  message: z.string().optional(),
+});
+export type EngineOpResponse = z.infer<typeof EngineOpResponse>;
+
+export const ErrorResponse = z.object({ error: z.string() });
+export type ErrorResponse = z.infer<typeof ErrorResponse>;

package/src/workspace-path-policy.ts

@@ -0,0 +1,41 @@
+import { ENGINE_ACCOUNT_PATH_RULES } from "./engine-account-paths";
+export { ENGINE_ACCOUNT_PATH_RULES } from "./engine-account-paths";
+/** Shared by cloud validation and runner reads. Check normalized and lexical
+ * components: normalization must never erase a traversal through credentials. */
+export function normalizedWorkspacePath(input: string): string {
+  if (!input.startsWith("/workspace/") || /[\x00-\x1f\x7f\\]/.test(input)) throw new Error("Use an absolute path under /workspace.");
+  const parts: string[] = [];
+  for (const part of input.split("/").slice(2)) {
+    if (!part || part === ".") continue;
+    if (part === "..") { if (!parts.length) throw new Error("Path escapes /workspace."); parts.pop(); }
+    else parts.push(part);
+  }
+  if (!parts.length) throw new Error("Choose a file under /workspace.");
+  return `/workspace/${parts.join("/")}`;
+}
+export function assertShareablePath(input: string): string { return validateShareablePath(input, ENGINE_ACCOUNT_PATH_RULES); }
+/** Kept self-contained for embedding together with its data in the agent CLI. */
+export function validateShareablePath(input: string, engineRules: ReadonlyArray<{ components: readonly string[]; prefix: boolean }>): string {
+  if (/[\x00-\x1f\x7f\\]/.test(input)) throw new Error("This path cannot be shared.");
+  if (!input.startsWith("/")) throw new Error("Use an absolute file path.");
+  const lexical = input.split("/").filter(Boolean);
+  const parts: string[] = [];
+  for (const part of lexical) {
+    if (part === "..") parts.pop(); else if (part !== ".") parts.push(part);
+    // Refuse entering these roots even when later '..' components erase them.
+    if (engineRules.some((rule) => parts.some((_, i) => rule.components.every((component, offset) => offset === rule.components.length - 1 && rule.prefix ? (parts[i + offset] ?? "").startsWith(component) : parts[i + offset] === component)))) throw new Error("Credential and Moondeck internal paths cannot be shared.");
+    if (["proc", "sys"].includes(parts[0] ?? "") || (parts[0] === "run" && ((parts[1] ?? "").startsWith("uai") || parts[1] === "secrets"))) throw new Error("Credential and Moondeck internal paths cannot be shared.");
+  }
+  const normalized = `/${parts.join("/")}`;
+  // Keep this function self-contained: its source is embedded into the
+  // dependency-free CLI. Inline callbacks need no compiler name helpers.
+  for (const components of [lexical, parts]) {
+    if (components.some((part, i) =>
+      (part === ".env" || (part.startsWith(".env.") && ![".env.example", ".env.schema"].includes(part))) ||
+      part.startsWith(".codex") ||
+      [".git", ".claude", ".ssh", ".grok", ".cursor", ".opencode", ".claude.json", ".git-credentials", ".netrc", ".npmrc", ".pypirc", ".aws", ".docker", ".kube", ".gnupg"].includes(part) ||
+      (part === ".config" && components[i + 1] === "gh") ||
+      ((part === ".uai" || part === ".moondeck") && components[i + 1] !== "attachments"))) throw new Error("Credential and Moondeck internal paths cannot be shared.");
+  }
+  return normalized;
+}