@spacefast/common 0.0.12 → 0.0.17

package/dist/utils/query-keys.js

@@ -10,7 +10,6 @@ export const qk = {
     agentAccounts: (teamId) => ["agent-accounts", teamId],
     myShelf: () => ["my-shelf"],
     mcpDashboard: (teamId) => ["mcp", "dashboard", teamId],
-    mcpApproval: (teamId, id) => ["mcp", "approval", teamId, id],
     // The teams LIST gets its own leaf so invalidating it never cascades into
     // ["teams", id, ...] resource queries (members, spaces, domains, ...).
     teams: () => ["teams", "list"],
@@ -71,7 +70,6 @@ export const qk = {
         : ["spaces", id, "versions", versionId, "comments", 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"],
     spaceVersionFileUrlPreview: (id, versionId, path) => ["spaces", id, "versions", versionId, "files", path, "url-preview"],
     spaceVersionFileDiff: (id, versionId, baseVersionId) => ["spaces", id, "versions", versionId, "files", "diff", baseVersionId ?? ""],
     spaceVersionConventionArtifacts: (id, versionId) => ["spaces", id, "versions", versionId, "convention-artifacts"],
@@ -81,20 +79,21 @@ export const qk = {
     spaceDomains: (id) => ["spaces", id, "domains"],
     spaceRuntimeStatus: (id) => ["spaces", id, "runtime"],
     spaceApplyState: (id) => ["spaces", id, "apply-state"],
-    spaceZero: (id) => ["spaces", id, "zero"],
-    spaceZeroDb: (id) => ["spaces", id, "zero", "db"],
-    spaceZeroLogs: (id, limit) => ["spaces", id, "zero", "logs", limit],
-    spaceZeroRealtimeEvents: (id, limit) => ["spaces", id, "zero", "realtime", "events", limit],
+    // A space has one database, whichever runtime claims it — the key says `db`,
+    // not `zero`, for the same reason the route does.
+    spaceDatabase: (id) => ["spaces", id, "db"],
+    // Row reads are per table and per page size; the bare prefix above sweeps
+    // every dump alongside the schema read.
+    spaceDatabaseDump: (id, table, limit) => [...qk.spaceDatabase(id), "dump", table ?? "", limit],
+    spaceStorage: (id) => ["spaces", id, "storage"],
+    spaceRuntimeLogs: (id, limit) => ["spaces", id, "logs", "runtime", limit],
+    spaceRuntimeRealtimeEvents: (id, limit) => [...qk.spaceRuntimeStatus(id), "realtime", "events", limit],
     spaceVariables: (id) => ["spaces", id, "variables"],
     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"],
     teamAgentHandoffs: (teamId) => ["teams", teamId, "agent-handoffs"],
     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"],
@@ -102,4 +101,9 @@ export const qk = {
     domainDnsOperations: (domainId) => ["domains", domainId, "dns", "operations"],
     domainActions: (domainId) => ["domains", domainId, "actions"],
     domainProviderConnections: (teamId) => ["domains", "provider-connections", teamId],
+    // The shell's notification bell. The bare prefix is the invalidate-all sweep
+    // that a "mark read" performs across both the count and every list view.
+    notifications: () => ["notifications"],
+    notificationsList: (unreadOnly) => ["notifications", "list", unreadOnly],
+    notificationsUnreadCount: () => ["notifications", "unread-count"],
 };

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

@@ -2,5 +2,8 @@ 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_COMMENTS_CONFIG_PATH: "/__spacefast/comments/config";
+export declare const RUNTIME_COMMENTS_TICKET_PATH: "/__spacefast/comments/ticket";
+export declare const RUNTIME_COMMENTS_VERSION_URLS_PATH: "/__spacefast/comments/version-urls";
 export declare function runtimeManagementPath(suffix: string): string;
 export declare function runtimeUploadPath(params: URLSearchParams | Record<string, string>): string;

package/dist/utils/runtime-paths.js

@@ -2,6 +2,13 @@ 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`;
+// Same-origin Comments exchange paths served on every published host. The PHP
+// mirror is SPACEFAST_COMMENTS_*_PATH in runtime/engine/shared/context.php;
+// runtime/tests/spacefast-sdk.test.ts pins the PHP side and
+// packages/collab-sdk/test/entry.test.ts pins the SDK side to these literals.
+export const RUNTIME_COMMENTS_CONFIG_PATH = `${SPACEFAST_RUNTIME_NAMESPACE}/comments/config`;
+export const RUNTIME_COMMENTS_TICKET_PATH = `${SPACEFAST_RUNTIME_NAMESPACE}/comments/ticket`;
+export const RUNTIME_COMMENTS_VERSION_URLS_PATH = `${SPACEFAST_RUNTIME_NAMESPACE}/comments/version-urls`;
 export function runtimeManagementPath(suffix) {
     const route = normalizeRuntimeRoute(suffix);
     if (route === "/") {

package/dist/utils/secure-local-file.d.ts

@@ -0,0 +1,73 @@
+import { type FileHandle } from "node:fs/promises";
+export declare class SecureLocalFileError extends Error {
+    name: string;
+}
+export declare class SecureLocalFileConflictError extends SecureLocalFileError {
+    name: string;
+}
+export type SecureWriteOptions = {
+    root: string;
+    relativePath: string;
+    data?: Uint8Array | string;
+    write?: (file: FileHandle) => Promise<void>;
+    overwrite?: boolean;
+    mode?: number;
+    rootMode?: number;
+    expectedContent?: Uint8Array | string | null;
+    beforeCommit?: () => void | Promise<void>;
+    /** Fault-injection hook after rollback custody exists but before the atomic rename. */
+    afterBackup?: () => void | Promise<void>;
+};
+export type SecureReadOptions = {
+    root: string;
+    relativePath: string;
+    encoding?: BufferEncoding;
+};
+export type SecureDirectoryOptions = {
+    root: string;
+    relativePath: string;
+    mode?: number;
+};
+export type SecureLocalEntryIdentity = {
+    ctimeNs: bigint;
+    dev: bigint;
+    ino: bigint;
+    mode: bigint;
+};
+export type SecureRemoveOptions = {
+    root: string;
+    relativePath: string;
+    expectedIdentity: SecureLocalEntryIdentity;
+};
+export type SecureCreatedDirectory = {
+    path: string;
+    validate: () => Promise<void>;
+    commit: () => Promise<void>;
+    rollback: () => Promise<void>;
+};
+export declare function secureOutputLocation(trustedPath: string, outputPath: string): {
+    root: string;
+    relativePath: string;
+};
+/**
+ * Writes beneath an explicitly trusted root without following output-tree
+ * symlinks. Linux uses descriptor-relative operations; other supported
+ * platforms use exclusive staging plus before-and-after ancestor identity
+ * validation and fail closed if any binding changes.
+ */
+export declare function secureWriteFile(options: SecureWriteOptions): Promise<void>;
+export declare function secureReadFile(options: SecureReadOptions & {
+    encoding: BufferEncoding;
+}): Promise<string>;
+export declare function secureReadFile(options: SecureReadOptions): Promise<Buffer>;
+/**
+ * Removes only the exact non-directory leaf identity previously inspected.
+ * The same leaf lock used by secureWriteFile covers the identity check and
+ * rename, so a cooperating writer cannot replace the leaf between them.
+ */
+export declare function secureRemoveLocalEntry(options: SecureRemoveOptions): Promise<boolean>;
+/**
+ * Creates one new directory leaf beneath a trusted root. The returned rollback
+ * removes only the exact directory inode created by this call.
+ */
+export declare function secureCreateDirectory(options: SecureDirectoryOptions): Promise<SecureCreatedDirectory>;