@spacefast/common 0.0.5 → 0.0.7

package/dist/utils/query-keys.js

@@ -4,8 +4,11 @@ export const qk = {
     accountSessions: () => ["account", "sessions"],
     accountConnections: () => ["account", "connections"],
     accountInvitations: () => ["account", "invitations"],
-    apiTokens: () => ["api-tokens"],
+    // Results are team-filtered, so the team lands in the key; calling with no
+    // teamId yields the bare prefix (personal scope, and invalidate-all sweeps).
+    apiTokens: (teamId) => teamId === undefined ? ["api-tokens"] : ["api-tokens", teamId],
     agentAccounts: () => ["agent-accounts"],
+    myShelf: () => ["my-shelf"],
     mcpDashboard: () => ["mcp", "dashboard"],
     mcpApproval: (id) => ["mcp", "approval", id],
     // The teams LIST gets its own leaf so invalidating it never cascades into
@@ -30,14 +33,29 @@ export const qk = {
     space: (id) => ["spaces", id],
     spaceByRef: (teamRef, spaceRef) => ["spaces", "by-ref", teamRef, spaceRef],
     spaceVersions: (id) => ["spaces", id, "versions"],
+    // The cursor-paginated history read (distinct cache shape from the plain,
+    // capped-at-50 `spaceVersions` list above) — nested under the same prefix so
+    // `invalidateQueries({ queryKey: qk.spaceVersions(id) })` still reaches it.
+    spaceVersionsHistory: (id) => [...qk.spaceVersions(id), "history"],
     spaceCollaboration: (id) => ["spaces", id, "collaboration"],
+    spaceCollaborationEmbedConfig: (id) => ["spaces", id, "collaboration", "embed-config"],
     spaceAnnotations: (id) => ["spaces", id, "annotations"],
     spaceActivity: (id, limit) => ["spaces", id, "activity", limit],
     spaceDeployments: (id) => ["spaces", id, "deployments"],
     spaceTags: (id) => ["spaces", id, "tags"],
-    spaceTagVersion: (id, versionId) => ["spaces", id, "tags", "versions", versionId],
+    spaceTagVersion: (id, versionId) => ["spaces", id, "tags", versionId],
+    spaceTagDiff: (id, versionId) => ["spaces", id, "tags", versionId, "diff"],
+    spaceTagReleases: (id) => ["spaces", id, "tags", "releases"],
+    // The merged (system+team+space) read-only view; never a write base — see
+    // `fetchSpaceReleasedGraph` in apps/my/src/lib/space-queries.ts.
+    spaceTagsEffective: (id) => ["spaces", id, "tags", "effective"],
     build: (id) => ["builds", id],
-    buildLogs: (id) => ["builds", id, "logs"],
+    // Observers with different limits must not share a cache entry; calling with
+    // no limit yields the bare prefix for invalidating every limit at once.
+    buildLogs: (id, limit) => limit === undefined
+        ? ["builds", id, "logs"]
+        : ["builds", id, "logs", limit],
+    spaceBuilds: (id) => ["spaces", id, "builds"],
     spaceRepositoryConnection: (id, connectionType = "connected") => ["spaces", id, "repository-connection", connectionType],
     repositoryInstallations: (spaceId) => ["repository-connections", "installations", spaceId],
     repositoryInstallationRepositories: (installationId) => ["repository-connections", "installations", installationId, "repositories"],
@@ -47,7 +65,11 @@ export const qk = {
     webhook: (webhookId) => ["webhooks", webhookId],
     webhookDeliveries: (webhookId) => ["webhooks", webhookId, "deliveries"],
     spaceVersion: (id, versionId) => ["spaces", id, "versions", versionId],
-    spaceVersionAnnotations: (id, versionId, status = "open") => ["spaces", id, "versions", versionId, "annotations", status],
+    // Calling with no status yields the bare prefix, for invalidating every
+    // status-scoped annotations list at once.
+    spaceVersionAnnotations: (id, versionId, status) => status === undefined
+        ? ["spaces", id, "versions", versionId, "annotations"]
+        : ["spaces", id, "versions", versionId, "annotations", status],
     spaceVersionFiles: (id, versionId) => ["spaces", id, "versions", versionId, "files"],
     spaceVersionFile: (id, versionId, path) => ["spaces", id, "versions", versionId, "files", path],
     spaceVersionFileDirectUrl: (id, versionId, path) => ["spaces", id, "versions", versionId, "files", path, "direct-url"],
@@ -68,6 +90,11 @@ export const qk = {
     spaceCertificates: (id) => ["spaces", id, "runtime", "certificates"],
     spaceLogs: (id, kind) => ["spaces", id, "logs", kind],
     spaceAnalytics: (id, window) => ["spaces", id, "analytics", window],
+    spaceFirewall: (id) => ["spaces", id, "access", "firewall"],
+    spaceAccessViews: (id, since) => ["spaces", id, "access", "views", since ?? ""],
+    teamServiceTokens: (teamId) => ["teams", teamId, "access", "service-tokens"],
+    teamAccessDefaults: (teamId) => ["teams", teamId, "access", "defaults"],
+    teamAccessConnections: (teamId) => ["teams", teamId, "access", "connections"],
     domain: (teamId, ref) => ["teams", teamId, "domains", ref],
     domainDiagnostics: (teamId, domainId) => ["teams", teamId, "domains", domainId, "diagnostics"],
     domainDnsCapabilities: (domainId) => ["domains", domainId, "dns", "capabilities"],

package/dist/utils/runtime-paths.d.ts

@@ -2,6 +2,5 @@ export declare const SPACEFAST_RUNTIME_NAMESPACE: "/__spacefast";
 export declare const RUNTIME_MANAGEMENT_API_PATH: "/__spacefast/api.php";
 export declare const RUNTIME_UPLOAD_API_PATH: "/__spacefast/upload.php";
 export declare const RUNTIME_HEALTH_PATH: "/__spacefast/health.php";
-export declare const RUNTIME_ACCESS_CALLBACK_PATH: "/__spacefast/access-callback.php";
 export declare function runtimeManagementPath(suffix: string): string;
 export declare function runtimeUploadPath(params: URLSearchParams | Record<string, string>): string;

package/dist/utils/runtime-paths.js

@@ -2,7 +2,6 @@ export const SPACEFAST_RUNTIME_NAMESPACE = "/__spacefast";
 export const RUNTIME_MANAGEMENT_API_PATH = `${SPACEFAST_RUNTIME_NAMESPACE}/api.php`;
 export const RUNTIME_UPLOAD_API_PATH = `${SPACEFAST_RUNTIME_NAMESPACE}/upload.php`;
 export const RUNTIME_HEALTH_PATH = `${SPACEFAST_RUNTIME_NAMESPACE}/health.php`;
-export const RUNTIME_ACCESS_CALLBACK_PATH = `${SPACEFAST_RUNTIME_NAMESPACE}/access-callback.php`;
 export function runtimeManagementPath(suffix) {
     const route = normalizeRuntimeRoute(suffix);
     if (route === "/") {

package/dist/utils/runtime-upload-batch.d.ts

@@ -0,0 +1,18 @@
+import { Buffer } from "node:buffer";
+import { RUNTIME_UPLOAD_BATCH_MAX_BYTES, RUNTIME_UPLOAD_BATCH_MAX_FILES } from "./runtime-upload.js";
+import { type UploadTarget } from "./upload-session.js";
+export { RUNTIME_UPLOAD_BATCH_MAX_BYTES, RUNTIME_UPLOAD_BATCH_MAX_FILES };
+export type RuntimeBatchArchiveEntry = {
+    path: string;
+    getBytes(): Buffer | Promise<Buffer>;
+};
+export declare function runtimeBatchUploadUnsupported(error: unknown): boolean;
+export declare function batchTargetForUploadTarget(uploadId: string, target: UploadTarget): UploadTarget | null;
+export declare function tarPathParts(filePath: string): {
+    name: string;
+    prefix: string;
+} | null;
+export declare function tarEndSize(): number;
+export declare function tarEntrySize(path: string, size: number): number | null;
+export declare function tarPadding(size: number): number;
+export declare function tarArchive(entries: readonly RuntimeBatchArchiveEntry[], pathTooLongError: (path: string) => Error): Promise<Buffer<ArrayBuffer>>;

package/dist/utils/runtime-upload-batch.js

@@ -0,0 +1,90 @@
+import { Buffer } from "node:buffer";
+import { RUNTIME_UPLOAD_BATCH_MAX_BYTES, RUNTIME_UPLOAD_BATCH_MAX_FILES, } from "./runtime-upload.js";
+import { UploadTargetError } from "./upload-session.js";
+// Batch planning + tar-writing wire contract shared by the CLI and the control
+// plane's inline publish path. This is the sender half of the runtime's tar
+// batch parser (runtime/engine/admin/upload.php); any change here must stay in
+// lockstep with that file.
+export { RUNTIME_UPLOAD_BATCH_MAX_BYTES, RUNTIME_UPLOAD_BATCH_MAX_FILES };
+export function runtimeBatchUploadUnsupported(error) {
+    return error instanceof UploadTargetError && (error.status === 404 || error.status === 405);
+}
+export function batchTargetForUploadTarget(uploadId, target) {
+    const url = new URL(target.url);
+    if (!url.pathname.endsWith("/upload.php")) {
+        return null;
+    }
+    url.search = new URLSearchParams({ op: "batch", upload_id: uploadId }).toString();
+    return {
+        ...target,
+        path: "__spacefast_batch.tar",
+        method: "POST",
+        url: url.toString(),
+        headers: {
+            ...target.headers,
+            "content-type": "application/x-tar",
+        },
+    };
+}
+export function tarPathParts(filePath) {
+    if (Buffer.byteLength(filePath) <= 100) {
+        return { name: filePath, prefix: "" };
+    }
+    const segments = filePath.split("/");
+    const name = segments.pop() ?? "";
+    const prefix = segments.join("/");
+    if (!name || Buffer.byteLength(name) > 100 || Buffer.byteLength(prefix) > 155) {
+        return null;
+    }
+    return { name, prefix };
+}
+export function tarEndSize() {
+    return 1024;
+}
+export function tarEntrySize(path, size) {
+    if (!tarPathParts(path)) {
+        return null;
+    }
+    return 512 + size + tarPadding(size);
+}
+export function tarPadding(size) {
+    return (512 - (size % 512)) % 512;
+}
+export async function tarArchive(entries, pathTooLongError) {
+    const chunks = [];
+    for (const entry of entries) {
+        const parts = tarPathParts(entry.path);
+        if (!parts) {
+            throw pathTooLongError(entry.path);
+        }
+        const body = Buffer.from(await entry.getBytes());
+        const header = Buffer.alloc(512);
+        header.write(parts.name, 0, Math.min(100, Buffer.byteLength(parts.name)), "utf8");
+        header.write("0000644\0", 100, 8, "ascii");
+        header.write("0000000\0", 108, 8, "ascii");
+        header.write("0000000\0", 116, 8, "ascii");
+        header.write(body.length.toString(8).padStart(11, "0") + "\0", 124, 12, "ascii");
+        header.write("00000000000\0", 136, 12, "ascii");
+        header.fill(0x20, 148, 156);
+        header[156] = "0".charCodeAt(0);
+        header.write("ustar", 257, 5, "ascii");
+        header.write("00", 263, 2, "ascii");
+        if (parts.prefix) {
+            header.write(parts.prefix, 345, Math.min(155, Buffer.byteLength(parts.prefix)), "utf8");
+        }
+        let checksum = 0;
+        for (const byte of header) {
+            checksum += byte;
+        }
+        header.write(checksum.toString(8).padStart(6, "0"), 148, 6, "ascii");
+        header[154] = 0;
+        header[155] = 0x20;
+        chunks.push(header, body);
+        const padding = tarPadding(body.length);
+        if (padding > 0) {
+            chunks.push(Buffer.alloc(padding));
+        }
+    }
+    chunks.push(Buffer.alloc(tarEndSize()));
+    return Buffer.concat(chunks);
+}

package/dist/utils/runtime-upload.d.ts

@@ -1,4 +1,6 @@
 export declare const RUNTIME_UPLOAD_METHOD: "PUT";
+export declare const RUNTIME_UPLOAD_BATCH_MAX_FILES = 500;
+export declare const RUNTIME_UPLOAD_BATCH_MAX_BYTES: number;
 export declare function runtimeUploadCanonicalPath(path: string): string;
 export declare function runtimeUploadSessionBaseUrl(input: {
     baseUrl: string;

package/dist/utils/runtime-upload.js

@@ -1,5 +1,10 @@
 import { runtimeUploadPath } from "./runtime-paths.js";
 export const RUNTIME_UPLOAD_METHOD = "PUT";
+// Mirrors STATTIC_RUNTIME_UPLOAD_BATCH_MAX_FILES/_MAX_BYTES in
+// runtime/engine/admin/upload.php (parity-guarded in
+// apps/control-plane/src/runtime/php-policy-parity.test.ts).
+export const RUNTIME_UPLOAD_BATCH_MAX_FILES = 500;
+export const RUNTIME_UPLOAD_BATCH_MAX_BYTES = 8 * 1024 * 1024;
 export function runtimeUploadCanonicalPath(path) {
     // Canonical path form (spec "Upload Contract"): UTF-8, Unicode NFC,
     // percent-encoded once. The runtime rejects non-canonical encodings.

package/dist/utils/sf-config-v1.d.ts

@@ -0,0 +1,2 @@
+import { type CompileSfConfigV1Options, type SfConfigV1CompileResult } from "../contracts/sf-config-v1.js";
+export declare function compileSfConfigV1(source: string, options?: CompileSfConfigV1Options): SfConfigV1CompileResult;