station-kit 1.0.7 → 1.0.9

package/src/app/schedules/new/page.tsx

@@ -0,0 +1,166 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import { useRouter } from "next/navigation";
+import { useApi } from "../../hooks/use-api";
+import { useBreadcrumb } from "../../hooks/use-breadcrumb";
+import { ScheduleForm, type ScheduleFormValue } from "../components/schedule-form";
+import { ApiPanel } from "../../components/api-panel";
+
+const INITIAL: ScheduleFormValue = {
+  kind: "signal",
+  target: "",
+  interval: "5m",
+  input: "{}",
+  enabled: true,
+};
+
+const INTERVAL_REGEX = /^(\d+)(ms|s|m|h|d|w)$/i;
+const UNIT_MS: Record<string, number> = {
+  ms: 1, s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000,
+};
+
+function parseIntervalLocal(s: string): number | null {
+  const m = INTERVAL_REGEX.exec(s.trim());
+  if (!m) return null;
+  return Number(m[1]) * UNIT_MS[m[2].toLowerCase()];
+}
+
+export default function NewSchedulePage() {
+  const api = useApi();
+  const router = useRouter();
+  const [value, setValue] = useState<ScheduleFormValue>(INITIAL);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useBreadcrumb(
+    [
+      { label: "Schedules", href: "/schedules" },
+      { label: "New" },
+    ],
+    "schedules",
+  );
+
+  // Compute the next 5 fire times locally so users can see the cadence
+  // before saving.
+  const previewFires = useMemo(() => {
+    const ms = parseIntervalLocal(value.interval);
+    if (ms === null || ms <= 0) return [];
+    const now = Date.now();
+    const out: string[] = [];
+    for (let i = 1; i <= 5; i++) {
+      out.push(new Date(now + ms * i).toISOString());
+    }
+    return out;
+  }, [value.interval]);
+
+  async function handleSave() {
+    setError(null);
+    if (!value.target) {
+      setError("Target is required.");
+      return;
+    }
+    let inputParsed: unknown = undefined;
+    if (value.input.trim()) {
+      try {
+        inputParsed = JSON.parse(value.input);
+      } catch (err) {
+        setError(`Input JSON parse error: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+      }
+    }
+    setBusy(true);
+    try {
+      const res = await api.createSchedule({
+        kind: value.kind,
+        target: value.target,
+        interval: value.interval,
+        input: inputParsed,
+        enabled: value.enabled,
+      });
+      router.push(`/schedules/${res.data.id}`);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <div>
+      <h1 className="page-title">New schedule</h1>
+
+      <div style={{ display: "grid", gridTemplateColumns: "minmax(0, 2fr) minmax(0, 1fr)", gap: "2rem" }}>
+        <div>
+          <ScheduleForm value={value} onChange={setValue} />
+
+          {error && (
+            <div style={{
+              marginTop: "1rem",
+              padding: "0.625rem 0.75rem",
+              background: "var(--error-bg, #fee)",
+              color: "var(--error, #b00)",
+              border: "1px solid var(--error, #b00)",
+              borderRadius: "4px",
+              fontSize: "0.8125rem",
+              maxWidth: "640px",
+            }}>{error}</div>
+          )}
+
+          <div style={{ marginTop: "1.5rem", display: "flex", gap: "0.5rem" }}>
+            <button className="btn btn--primary" onClick={handleSave} disabled={busy}>
+              {busy ? "Creating..." : "Create schedule"}
+            </button>
+            <button className="btn" onClick={() => router.push("/schedules")}>Cancel</button>
+          </div>
+        </div>
+
+        <aside>
+          <h3 className="mono" style={{ fontSize: "0.75rem", color: "var(--muted)", textTransform: "uppercase", letterSpacing: "0.05em", marginBottom: "0.5rem" }}>
+            Next fire times (preview)
+          </h3>
+          {previewFires.length === 0 ? (
+            <div className="mono" style={{ fontSize: "0.75rem", color: "var(--error, #b00)" }}>
+              Invalid interval. Use formats like &quot;30s&quot;, &quot;5m&quot;, &quot;1h&quot;, &quot;1d&quot;, &quot;1w&quot;.
+            </div>
+          ) : (
+            <ul style={{ listStyle: "none", padding: 0, margin: 0 }}>
+              {previewFires.map((iso, i) => (
+                <li key={i} className="mono" style={{
+                  fontSize: "0.8125rem",
+                  padding: "0.375rem 0",
+                  borderBottom: "1px dashed var(--border)",
+                  color: i === 0 ? "var(--text)" : "var(--muted)",
+                }}>
+                  {new Date(iso).toLocaleString()}
+                </li>
+              ))}
+            </ul>
+          )}
+        </aside>
+      </div>
+
+      <ApiPanel
+        title="Create this schedule"
+        snippets={[
+          {
+            label: "POST /api/v1/schedules",
+            method: "POST",
+            path: "/api/v1/schedules",
+            body: {
+              kind: value.kind,
+              target: value.target,
+              interval: value.interval,
+              enabled: value.enabled,
+              input: tryParse(value.input),
+            },
+          },
+        ]}
+      />
+    </div>
+  );
+}
+
+function tryParse(s: string): unknown {
+  try { return JSON.parse(s); } catch { return s; }
+}

package/src/app/schedules/page.tsx

@@ -0,0 +1,126 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { useApi, type Schedule } from "../hooks/use-api";
+import { useBreadcrumb } from "../hooks/use-breadcrumb";
+import { ApiPanel } from "../components/api-panel";
+
+const KIND_LABEL: Record<Schedule["kind"], string> = {
+  signal: "Signal",
+  "broadcast-static": "Broadcast (file)",
+  "broadcast-dynamic": "Broadcast (dynamic)",
+};
+
+export default function SchedulesPage() {
+  const api = useApi();
+  const router = useRouter();
+  const [schedules, setSchedules] = useState<Schedule[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useBreadcrumb([{ label: "Schedules" }], "schedules");
+
+  useEffect(() => {
+    api.getSchedules()
+      .then((res) => setSchedules(res.data))
+      .catch((err) => setError(err instanceof Error ? err.message : String(err)))
+      .finally(() => setLoading(false));
+  }, []);
+
+  if (loading) {
+    return (
+      <div>
+        <h1 className="page-title">Schedules</h1>
+        <div className="loading-bar"><div className="loading-bar-fill" /></div>
+      </div>
+    );
+  }
+
+  return (
+    <div>
+      <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: "1rem" }}>
+        <h1 className="page-title" style={{ margin: 0 }}>Schedules</h1>
+        <Link href="/schedules/new" className="btn btn--primary">+ New schedule</Link>
+      </div>
+
+      {error && (
+        <div style={{
+          marginBottom: "1rem",
+          padding: "0.625rem 0.75rem",
+          background: "var(--error-bg, #fee)",
+          color: "var(--error, #b00)",
+          borderRadius: "4px",
+          fontSize: "0.8125rem",
+        }}>{error}</div>
+      )}
+
+      {schedules.length === 0 ? (
+        <div className="empty-state">
+          <p className="empty-state-text">
+            No schedules yet. <Link href="/schedules/new">Create one</Link> to fire signals or broadcasts on intervals.
+          </p>
+        </div>
+      ) : (
+        <table className="station-table">
+          <thead>
+            <tr>
+              <th>Target</th>
+              <th>Kind</th>
+              <th>Interval</th>
+              <th>Next run</th>
+              <th>Last run</th>
+              <th>Status</th>
+              <th></th>
+            </tr>
+          </thead>
+          <tbody>
+            {schedules.map((s) => (
+              <tr
+                key={s.id}
+                className="clickable-row"
+                onClick={() => router.push(`/schedules/${s.id}`)}
+              >
+                <td className="mono">{s.target}</td>
+                <td className="mono" style={{ fontSize: "0.75rem", color: "var(--muted)" }}>{KIND_LABEL[s.kind]}</td>
+                <td className="mono">{s.interval}</td>
+                <td className="mono" style={{ fontSize: "0.75rem", color: "var(--muted)" }}>
+                  {new Date(s.nextRunAt).toLocaleString()}
+                </td>
+                <td className="mono" style={{ fontSize: "0.75rem", color: "var(--muted)" }}>
+                  {s.lastRunAt ? new Date(s.lastRunAt).toLocaleString() : "—"}
+                </td>
+                <td className="mono" style={{ fontSize: "0.75rem" }}>
+                  <span style={{
+                    padding: "0.125rem 0.375rem",
+                    borderRadius: "3px",
+                    background: s.enabled ? "var(--success-bg, #efe)" : "var(--surface)",
+                    color: s.enabled ? "var(--success, #060)" : "var(--muted)",
+                  }}>
+                    {s.enabled ? "enabled" : "disabled"}
+                  </span>
+                </td>
+                <td></td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+
+      <ApiPanel
+        title="List & manage schedules"
+        snippets={[
+          { label: "List all", method: "GET", path: "/api/v1/schedules" },
+          { label: "List by kind", method: "GET", path: "/api/v1/schedules", query: { kind: "signal" } },
+          {
+            label: "Create",
+            method: "POST",
+            path: "/api/v1/schedules",
+            body: { kind: "signal", target: "<signalName>", interval: "5m", enabled: true, input: {} },
+          },
+        ]}
+      />
+    </div>
+  );
+}

package/src/config/schema.ts

@@ -1,10 +1,18 @@
 import type { SignalQueueAdapter } from "station-signal";
 import type { BroadcastQueueAdapter } from "station-broadcast";
+import type { ScheduleAdapter } from "station-schedules";
+import type { ApiKeyStorageAdapter } from "../server/auth/keys.js";
 
 export interface AuthConfig {
   username: string;
   password: string;
   sessionTtlMs?: number;
+  /**
+   * Pluggable storage backend for API keys. Defaults to a SQLite store at
+   * `<dataDir>/station-keys.db`. Provide a custom adapter to host keys in
+   * Postgres, MySQL, Redis, etc.
+   */
+  keyStorage?: ApiKeyStorageAdapter;
 }
 
 export interface RunnerConfig {
@@ -27,6 +35,11 @@ export interface StationConfig {
   host: string;
   adapter?: SignalQueueAdapter;
   broadcastAdapter?: BroadcastQueueAdapter;
+  /**
+   * Optional schedule storage adapter. When provided, runtime-editable
+   * schedules are persisted here and reconciled by both runners.
+   */
+  scheduleAdapter?: ScheduleAdapter;
   signalsDir?: string;
   broadcastsDir?: string;
   stationDir: string;
@@ -85,6 +98,7 @@ export function resolveConfig(input: StationUserConfig): StationConfig {
     host: input.host ?? envHost ?? DEFAULTS.host,
     adapter: input.adapter,
     broadcastAdapter: input.broadcastAdapter,
+    scheduleAdapter: input.scheduleAdapter,
     signalsDir: input.signalsDir,
     broadcastsDir: input.broadcastsDir,
     stationDir: input.stationDir ?? DEFAULTS.stationDir,

package/src/index.ts

@@ -5,3 +5,5 @@ export function defineConfig(config: StationUserConfig): StationUserConfig {
 }
 
 export type { StationConfig, StationUserConfig, AuthConfig, DeployConfig } from "./config/schema.js";
+export { resolveConfig } from "./config/schema.js";
+export { loadConfig } from "./config/loader.js";

package/src/server/auth/keys.ts

@@ -13,14 +13,49 @@ export interface ApiKey {
   revoked: boolean;
 }
 
-export class KeyStore {
+export type ApiKeyPublic = Omit<ApiKey, "keyHash">;
+
+/**
+ * Pluggable storage backend for API keys. Implementations only persist and
+ * query records — hashing, key generation, and verification logic live in
+ * the KeyStore. May be sync or async; the KeyStore awaits all results.
+ */
+export interface ApiKeyStorageAdapter {
+  insert(record: ApiKey): Promise<void> | void;
+  findByHash(keyHash: string): Promise<ApiKey | null> | ApiKey | null;
+  list(): Promise<ApiKeyPublic[]> | ApiKeyPublic[];
+  touch(id: string, lastUsedIso: string): Promise<void> | void;
+  revoke(id: string): Promise<boolean> | boolean;
+  close?(): Promise<void> | void;
+}
+
+// ─── SQLite default ─────────────────────────────────────────────────
+
+export interface SqliteKeyStorageOptions {
+  dbPath: string;
+  /** Override the table name (default: "api_keys"). */
+  tableName?: string;
+}
+
+/**
+ * Default ApiKeyStorageAdapter backed by better-sqlite3. Used by the Station
+ * server when no `keyStorage` is configured. For Postgres / MySQL / Redis,
+ * implement `ApiKeyStorageAdapter` and pass it to `KeyStore` directly.
+ */
+export class SqliteKeyStorage implements ApiKeyStorageAdapter {
   private db: Database.Database;
+  private table: string;
 
-  constructor(dbPath: string) {
-    this.db = new Database(dbPath);
+  constructor(options: SqliteKeyStorageOptions) {
+    const tableName = options.tableName ?? "api_keys";
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName)) {
+      throw new Error(`Invalid table name "${tableName}"`);
+    }
+    this.table = tableName;
+    this.db = new Database(options.dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.exec(`
-      CREATE TABLE IF NOT EXISTS api_keys (
+      CREATE TABLE IF NOT EXISTS ${this.table} (
         id          TEXT PRIMARY KEY,
         name        TEXT NOT NULL,
         key_hash    TEXT NOT NULL UNIQUE,
@@ -34,79 +69,179 @@ export class KeyStore {
     `);
   }
 
+  insert(record: ApiKey): void {
+    this.db.prepare(`
+      INSERT INTO ${this.table}
+        (id, name, key_hash, key_prefix, scopes, created_at, last_used, expires_at, revoked)
+      VALUES
+        (@id, @name, @key_hash, @key_prefix, @scopes, @created_at, @last_used, @expires_at, @revoked)
+    `).run({
+      id: record.id,
+      name: record.name,
+      key_hash: record.keyHash,
+      key_prefix: record.keyPrefix,
+      scopes: JSON.stringify(record.scopes),
+      created_at: record.createdAt,
+      last_used: record.lastUsed,
+      expires_at: record.expiresAt,
+      revoked: record.revoked ? 1 : 0,
+    });
+  }
+
+  findByHash(keyHash: string): ApiKey | null {
+    const row = this.db
+      .prepare(`SELECT id, name, key_hash, key_prefix, scopes, created_at, last_used, expires_at, revoked
+                FROM ${this.table} WHERE key_hash = ?`)
+      .get(keyHash) as Record<string, unknown> | undefined;
+    return row ? rowToApiKey(row) : null;
+  }
+
+  list(): ApiKeyPublic[] {
+    const rows = this.db
+      .prepare(`SELECT id, name, key_prefix, scopes, created_at, last_used, expires_at, revoked
+                FROM ${this.table} ORDER BY created_at DESC`)
+      .all() as Record<string, unknown>[];
+    return rows.map((row) => ({
+      id: row.id as string,
+      name: row.name as string,
+      keyPrefix: row.key_prefix as string,
+      scopes: JSON.parse(row.scopes as string),
+      createdAt: row.created_at as string,
+      lastUsed: (row.last_used as string | null) ?? null,
+      expiresAt: (row.expires_at as string | null) ?? null,
+      revoked: Boolean(row.revoked),
+    }));
+  }
+
+  touch(id: string, lastUsedIso: string): void {
+    this.db.prepare(`UPDATE ${this.table} SET last_used = ? WHERE id = ?`).run(lastUsedIso, id);
+  }
+
+  revoke(id: string): boolean {
+    const result = this.db.prepare(`UPDATE ${this.table} SET revoked = 1 WHERE id = ?`).run(id);
+    return result.changes > 0;
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}
+
+function rowToApiKey(row: Record<string, unknown>): ApiKey {
+  return {
+    id: row.id as string,
+    name: row.name as string,
+    keyHash: row.key_hash as string,
+    keyPrefix: row.key_prefix as string,
+    scopes: JSON.parse(row.scopes as string),
+    createdAt: row.created_at as string,
+    lastUsed: (row.last_used as string | null) ?? null,
+    expiresAt: (row.expires_at as string | null) ?? null,
+    revoked: Boolean(row.revoked),
+  };
+}
+
+// ─── In-memory storage for tests / ephemeral deployments ────────────
+
+export class MemoryKeyStorage implements ApiKeyStorageAdapter {
+  private records = new Map<string, ApiKey>();
+
+  insert(record: ApiKey): void {
+    this.records.set(record.id, { ...record });
+  }
+
+  findByHash(keyHash: string): ApiKey | null {
+    for (const r of this.records.values()) {
+      if (r.keyHash === keyHash) return { ...r };
+    }
+    return null;
+  }
+
+  list(): ApiKeyPublic[] {
+    return Array.from(this.records.values())
+      .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+      .map((r) => {
+        const { keyHash: _h, ...rest } = r;
+        return rest;
+      });
+  }
+
+  touch(id: string, lastUsedIso: string): void {
+    const r = this.records.get(id);
+    if (r) r.lastUsed = lastUsedIso;
+  }
+
+  revoke(id: string): boolean {
+    const r = this.records.get(id);
+    if (!r) return false;
+    r.revoked = true;
+    return true;
+  }
+}
+
+// ─── KeyStore — owns crypto, delegates persistence ──────────────────
+
+export class KeyStore {
+  private storage: ApiKeyStorageAdapter;
+
+  /**
+   * Pass an `ApiKeyStorageAdapter` for any backend. The string overload is
+   * retained for backwards compatibility — it constructs a SqliteKeyStorage
+   * at the given path.
+   */
+  constructor(storageOrDbPath: ApiKeyStorageAdapter | string) {
+    if (typeof storageOrDbPath === "string") {
+      this.storage = new SqliteKeyStorage({ dbPath: storageOrDbPath });
+    } else {
+      this.storage = storageOrDbPath;
+    }
+  }
+
   /** Generate a new API key. Returns the full key (only shown once) and the stored record. */
-  create(name: string, scopes: string[] = ["trigger", "read"]): { key: string; record: ApiKey } {
+  async create(name: string, scopes: string[] = ["trigger", "read"]): Promise<{ key: string; record: ApiKey }> {
     const id = crypto.randomUUID();
     const rawKey = `sk_live_${crypto.randomBytes(16).toString("hex")}`;
     const keyHash = crypto.createHash("sha256").update(rawKey).digest("hex");
     const keyPrefix = rawKey.slice(0, 12);
     const createdAt = new Date().toISOString();
 
-    this.db.prepare(`
-      INSERT INTO api_keys (id, name, key_hash, key_prefix, scopes, created_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(id, name, keyHash, keyPrefix, JSON.stringify(scopes), createdAt);
-
-    return {
-      key: rawKey,
-      record: { id, name, keyHash, keyPrefix, scopes, createdAt, lastUsed: null, expiresAt: null, revoked: false },
+    const record: ApiKey = {
+      id, name, keyHash, keyPrefix, scopes, createdAt,
+      lastUsed: null, expiresAt: null, revoked: false,
     };
+    await this.storage.insert(record);
+    return { key: rawKey, record };
   }
 
   /** Verify an API key. Returns the key record if valid, null otherwise. */
-  verify(rawKey: string): ApiKey | null {
+  async verify(rawKey: string): Promise<ApiKey | null> {
     const keyHash = crypto.createHash("sha256").update(rawKey).digest("hex");
-    const row = this.db.prepare(`
-      SELECT id, name, key_hash, key_prefix, scopes, created_at, last_used, expires_at, revoked
-      FROM api_keys WHERE key_hash = ?
-    `).get(keyHash) as Record<string, unknown> | undefined;
+    const record = await this.storage.findByHash(keyHash);
+    if (!record) return null;
+    if (record.revoked) return null;
+    if (record.expiresAt && new Date(record.expiresAt) < new Date()) return null;
 
-    if (!row) return null;
-    if (row.revoked) return null;
-    if (row.expires_at && new Date(row.expires_at as string) < new Date()) return null;
+    // Touch is best-effort — don't block verification on the write. Wrap in
+    // an explicit deferred so a synchronous throw from a sync `touch()` is
+    // also swallowed, matching the async case.
+    Promise.resolve()
+      .then(() => this.storage.touch(record.id, new Date().toISOString()))
+      .catch(() => {});
 
-    // Update last_used
-    this.db.prepare("UPDATE api_keys SET last_used = ? WHERE id = ?").run(new Date().toISOString(), row.id);
-
-    return {
-      id: row.id as string,
-      name: row.name as string,
-      keyHash: row.key_hash as string,
-      keyPrefix: row.key_prefix as string,
-      scopes: JSON.parse(row.scopes as string),
-      createdAt: row.created_at as string,
-      lastUsed: row.last_used as string | null,
-      expiresAt: row.expires_at as string | null,
-      revoked: Boolean(row.revoked),
-    };
+    return record;
   }
 
   /** List all keys (without hashes). */
-  list(): Omit<ApiKey, "keyHash">[] {
-    const rows = this.db.prepare(`
-      SELECT id, name, key_prefix, scopes, created_at, last_used, expires_at, revoked
-      FROM api_keys ORDER BY created_at DESC
-    `).all() as Record<string, unknown>[];
-
-    return rows.map((row) => ({
-      id: row.id as string,
-      name: row.name as string,
-      keyPrefix: row.key_prefix as string,
-      scopes: JSON.parse(row.scopes as string),
-      createdAt: row.created_at as string,
-      lastUsed: row.last_used as string | null,
-      expiresAt: row.expires_at as string | null,
-      revoked: Boolean(row.revoked),
-    }));
+  async list(): Promise<ApiKeyPublic[]> {
+    return this.storage.list();
   }
 
   /** Revoke a key by ID. */
-  revoke(id: string): boolean {
-    const result = this.db.prepare("UPDATE api_keys SET revoked = 1 WHERE id = ?").run(id);
-    return result.changes > 0;
+  async revoke(id: string): Promise<boolean> {
+    return this.storage.revoke(id);
   }
 
-  close(): void {
-    this.db.close();
+  async close(): Promise<void> {
+    if (this.storage.close) await this.storage.close();
   }
 }