@astrale-domains/services 0.2.0

package/dist/schema/service/methods.d.ts

@@ -0,0 +1,135 @@
+export declare const serviceMethods: {
+    readonly deploy: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        path: string;
+        name?: string | undefined;
+        entry?: string | undefined;
+        modules?: ({
+            contentBase64: string;
+            name: string;
+            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+        } | {
+            contentBase64Chunks: string[];
+            name: string;
+            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+        })[] | undefined;
+        revisioned?: {
+            revision: string;
+            release: {
+                entry: string;
+                modules: ({
+                    contentBase64: string;
+                    name: string;
+                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                } | {
+                    contentBase64Chunks: string[];
+                    name: string;
+                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                })[];
+            };
+            gateway: {
+                entry: string;
+                modules: ({
+                    contentBase64: string;
+                    name: string;
+                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                } | {
+                    contentBase64Chunks: string[];
+                    name: string;
+                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                })[];
+            };
+        } | undefined;
+        compatibilityDate?: string | undefined;
+        compatibilityFlags?: string[] | undefined;
+        serviceBindings?: {
+            name: string;
+            service: string;
+        }[] | undefined;
+        vars?: Record<string, string> | undefined;
+        secrets?: Record<string, string> | undefined;
+        assets?: {
+            files: ({
+                contentBase64: string;
+                path: string;
+                contentType?: string | undefined;
+            } | {
+                contentBase64Chunks: string[];
+                path: string;
+                contentType?: string | undefined;
+            })[];
+            notFound?: "404-page" | "none" | "single-page-application" | undefined;
+            runWorkerFirst?: boolean | undefined;
+            htmlHandling?: "none" | undefined;
+        } | undefined;
+        limits?: {
+            cpuMs?: number | undefined;
+            subrequests?: number | undefined;
+        } | undefined;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            path: string;
+            url: string;
+            digest: string;
+            revision?: string | undefined;
+            state: "deploying" | "failed" | "ready";
+            error?: string | null | undefined;
+            functions: {
+                id: string;
+                path: string;
+                ref: string;
+            }[];
+        };
+    }, "authenticated", true, "default">>;
+    readonly setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        name: string;
+        value: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            name: string;
+        };
+    }, "authenticated", false, "default">>;
+    readonly deleteSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        name: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            ok: true;
+        };
+    }, "authenticated", false, "default">>;
+    readonly secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: string[];
+    }, "authenticated", false, "default">>;
+    readonly setSchedule: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        crons: string[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            crons: string[];
+        };
+    }, "authenticated", false, "default">>;
+    readonly schedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: string[];
+    }, "authenticated", false, "default">>;
+    readonly logs: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        tail?: number | undefined;
+        since?: number | undefined;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            ts: number;
+            level: string;
+            line: string;
+        }[];
+    }, "authenticated", false, "default">>;
+    readonly delete: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            ok: true;
+        };
+    }, "authenticated", false, "default">>;
+};

package/dist/schema/service/methods.js

@@ -0,0 +1,64 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { deployServiceInput, deployServiceOutput } from '#schema/deployment';
+const secretName = z.string().min(1).max(256);
+export const serviceMethods = {
+    deploy: method({
+        description: 'Create or replace one Cloudflare Worker placement.',
+        auth: 'authenticated',
+        static: true,
+        input: deployServiceInput,
+        output: deployServiceOutput,
+    }),
+    setSecret: method({
+        description: 'Set one write-only Service secret.',
+        auth: 'authenticated',
+        input: z.strictObject({
+            name: secretName,
+            value: z
+                .string()
+                .min(1)
+                .max(64 * 1024),
+        }),
+        output: z.strictObject({ name: secretName }),
+    }),
+    deleteSecret: method({
+        description: 'Delete one write-only Service secret.',
+        auth: 'authenticated',
+        input: z.strictObject({ name: secretName }),
+        output: z.strictObject({ ok: z.literal(true) }),
+    }),
+    secrets: method({
+        description: 'List write-only secret names.',
+        auth: 'authenticated',
+        input: z.strictObject({}),
+        output: z.array(secretName),
+    }),
+    setSchedule: method({
+        description: 'Replace the complete Service cron set.',
+        auth: 'authenticated',
+        input: z.strictObject({ crons: z.array(z.string()).max(24) }),
+        output: z.strictObject({ crons: z.array(z.string()) }),
+    }),
+    schedules: method({
+        description: 'List active Service cron expressions.',
+        auth: 'authenticated',
+        input: z.strictObject({}),
+        output: z.array(z.string()),
+    }),
+    logs: method({
+        description: 'Read recent Service runtime logs.',
+        auth: 'authenticated',
+        input: z.strictObject({
+            tail: z.number().int().min(1).max(1_000).optional(),
+            since: z.number().int().min(0).optional(),
+        }),
+        output: z.array(z.strictObject({ id: z.string(), ts: z.number(), level: z.string(), line: z.string() })),
+    }),
+    delete: method({
+        description: 'Delete the provider placement and Service record.',
+        auth: 'authenticated',
+        input: z.strictObject({}),
+        output: z.strictObject({ ok: z.literal(true) }),
+    }),
+};

package/dist/schema/service/policies.d.ts

@@ -0,0 +1,4 @@
+/** A Service is visible only to the Identity that owns its provider effects. */
+export declare const ObserveService: import("@astrale-os/sdk/schema").Policy;
+/** Ownership edges disclose only the subject's own Service relationship. */
+export declare const TraverseOwnedService: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/service/policies.js

@@ -0,0 +1,12 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { service_owned_by } from './relationships.js';
+/** A Service is visible only to the Identity that owns its provider effects. */
+export const ObserveService = policy({
+    description: 'The subject owns this Service.',
+    match: ({ edge, object, subject }) => edge({ source: subject, class: () => service_owned_by, target: object }),
+});
+/** Ownership edges disclose only the subject's own Service relationship. */
+export const TraverseOwnedService = policy({
+    description: 'The subject owns the Service at the target of this relationship.',
+    match: ({ allOf, edge, source, subject, target }) => allOf(edge({ source: subject, class: () => service_owned_by, target }), edge({ source, class: () => service_owned_by, target })),
+});

package/dist/schema/service/relationships.d.ts

@@ -0,0 +1,16 @@
+export declare const service_owned_by: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "owner";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "service";
+        readonly incoming: "1";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/service/relationships.js

@@ -0,0 +1,9 @@
+import { K, edgeClass } from '@astrale-os/sdk/schema';
+import { CloudflareWorker } from './class.js';
+import { TraverseOwnedService } from './policies.js';
+export const service_owned_by = edgeClass.directed({
+    description: 'The Identity that owns and may manage one Service.',
+    source: { as: 'owner', accepts: [K.classes.Identity], outgoing: '0..*' },
+    target: { as: 'service', accepts: [() => CloudflareWorker], incoming: '1' },
+    policies: { traverse: () => TraverseOwnedService },
+});

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@astrale-domains/services",
+  "version": "0.2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/astrale-os/domains.git",
+    "directory": "services"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/schema/index.js",
+  "types": "./dist/schema/index.d.ts",
+  "imports": {
+    "#schema": "./dist/schema/index.js",
+    "#schema/*": "./dist/schema/*/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/schema/index.d.ts",
+      "import": "./dist/schema/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@astrale-os/sdk": "0.5.0-beta.45",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@astrale-os/adapter-astrale": "0.5.0-beta.41",
+    "@astrale-os/adapter-cloudflare": "0.5.0-beta.48",
+    "@astrale-os/ox": ">=0.1.3 <1.0.0",
+    "@astrale-os/shell": "0.4.2-beta.3",
+    "@astrale-os/shell-react": "0.3.2-beta.2",
+    "@tailwindcss/vite": "^4.0.6",
+    "@tanstack/react-router": "1.170.17",
+    "@tanstack/router-plugin": "1.168.19",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "@vitejs/plugin-react": "^6.0.5",
+    "oxlint": ">=1.78.0 <2.0.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "tailwindcss": "^4.0.6",
+    "typescript": "7.0.2",
+    "vite": "^8.2.1",
+    "vitest": "^4.1.10"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "trustedDependencies": [
+    "esbuild",
+    "sharp",
+    "workerd"
+  ],
+  "scripts": {
+    "dev": "astrale-domain dev",
+    "prod": "astrale-domain deploy prod",
+    "deploy": "astrale-domain deploy",
+    "build": "astrale-domain build",
+    "lint": "astrale-domain lint",
+    "lint:fix": "astrale-domain lint --fix",
+    "package": "astrale-domain package",
+    "provider:bootstrap": "bun providers/cloudflare/operator/provision/bootstrap.ts",
+    "provider:route-wildcard": "bun providers/cloudflare/operator/routing/wildcard.ts",
+    "provider:route-tenant": "bun providers/cloudflare/operator/routing/tenant.ts",
+    "qualify:cloudflare": "bun scripts/qualification/cloudflare/run.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --config vitest.config.ts",
+    "frontend:dev": "vite",
+    "frontend:build": "vite build"
+  }
+}