@pstdio/sdk 0.23.0 → 0.24.1

package/dist/resources.d.ts

@@ -186,6 +186,7 @@ declare const sessionSchema: z.ZodObject<{
     cwd: z.ZodNullable<z.ZodString>;
     params_json: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
     anchors_json: z.ZodArray<z.ZodObject<{
+        shorthand: z.ZodOptional<z.ZodString>;
         type: z.ZodString;
         id: z.ZodString;
         projectId: z.ZodOptional<z.ZodString>;
@@ -213,6 +214,7 @@ declare const sessionStatusSchema: z.ZodEnum<{
 export declare type Settings = z.infer<typeof settingsSchema>;
 
 declare const settingsSchema: z.ZodObject<{
+    notifications_enabled: z.ZodBoolean;
     max_concurrent_sessions: z.ZodNullable<z.ZodNumber>;
 }, z.core.$strip>;
 
@@ -354,6 +356,7 @@ declare const workspaceListItemSchema: z.ZodObject<{
     workspace_shorthand: z.ZodString;
     startup_log_file_id: z.ZodNullable<z.ZodString>;
     anchors_json: z.ZodArray<z.ZodObject<{
+        shorthand: z.ZodOptional<z.ZodString>;
         type: z.ZodString;
         id: z.ZodString;
         projectId: z.ZodOptional<z.ZodString>;
@@ -406,6 +409,7 @@ declare const workspaceSchema: z.ZodObject<{
     workspace_shorthand: z.ZodString;
     startup_log_file_id: z.ZodNullable<z.ZodString>;
     anchors_json: z.ZodArray<z.ZodObject<{
+        shorthand: z.ZodOptional<z.ZodString>;
         type: z.ZodString;
         id: z.ZodString;
         projectId: z.ZodOptional<z.ZodString>;

package/dist/testing/index.js

@@ -0,0 +1,207 @@
+// src/testing/memory-resources.ts
+var createMemoryResources = (prefixes, sequences = new Map) => ({
+  allocate: async ({ kind }) => {
+    const prefix = prefixes[kind];
+    if (!prefix)
+      throw new Error(`Undeclared resource kind: ${kind}`);
+    const next = (sequences.get(kind) ?? 0) + 1;
+    sequences.set(kind, next);
+    return { id: crypto.randomUUID(), shorthand: `${prefix}-${next}` };
+  }
+});
+
+// src/testing/command-context.ts
+var sequencesByStorage = new WeakMap;
+var paramsByContext = new WeakMap;
+var makeCommandContext = (input) => {
+  const { storage, params, projectId = "proj-1", overrides } = input;
+  let sequences = sequencesByStorage.get(storage);
+  if (!sequences) {
+    sequences = new Map;
+    sequencesByStorage.set(storage, sequences);
+  }
+  const resources = createMemoryResources(input.resourcePrefixes ?? {}, sequences);
+  const context = {
+    extensionId: "test.extension",
+    name: "test-extension",
+    projectId,
+    project: { id: projectId, name: "Test Project", shorthand: "T" },
+    storage,
+    resources,
+    invocation: { params },
+    events: { emit: async () => ({ delivered: 0 }) },
+    notify: { action: async () => ({}), dismiss: async () => [], resolve: async () => [], toast: async () => {} },
+    workspaces: { list: async () => [], get: async () => null, getByShorthand: async () => null },
+    sessions: { list: async () => [], listByWorkspace: async () => [], addAnchors: async () => {} },
+    ...overrides
+  };
+  paramsByContext.set(context, params);
+  return context;
+};
+var commandParamsFor = (context) => paramsByContext.get(context);
+var makeCommandArgs = (input) => [makeCommandContext(input), input.params];
+// src/testing/memory-repo-files.ts
+var createMemoryRepoFiles = () => {
+  const files = new Map;
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  return {
+    files,
+    exists: async (path) => files.has(path) || [...files.keys()].some((file) => file.startsWith(`${path}/`)),
+    readText: async (path) => {
+      const value = files.get(path);
+      if (value === undefined)
+        throw new Error(`File not found: ${path}`);
+      return decoder.decode(value);
+    },
+    writeText: async (path, value) => {
+      files.set(path, encoder.encode(value));
+    },
+    readBytes: async (path) => {
+      const value = files.get(path);
+      if (value === undefined)
+        throw new Error(`File not found: ${path}`);
+      return value;
+    },
+    writeBytes: async (path, value) => {
+      files.set(path, value);
+    },
+    list: async (pattern) => {
+      const prefix = pattern ? pattern.replace(/\*+.*/, "") : "";
+      return [...files.keys()].filter((path) => path.startsWith(prefix)).sort().map((path) => ({ path }));
+    },
+    listDirs: async () => [],
+    delete: async (path) => {
+      const matches = [...files.keys()].filter((file) => file === path || file.startsWith(`${path}/`));
+      if (matches.length === 0)
+        throw Object.assign(new Error(`ENOENT: ${path}`), { code: "ENOENT" });
+      for (const file of matches)
+        files.delete(file);
+    }
+  };
+};
+// src/testing/memory-storage.ts
+var createMemoryStorage = () => {
+  const kv = new Map;
+  const collections = new Map;
+  const blobStores = new Map;
+  const collectionStore = (name) => {
+    const existing = collections.get(name);
+    if (existing)
+      return existing;
+    const created = new Map;
+    collections.set(name, created);
+    return created;
+  };
+  const blobStore = (name) => {
+    const existing = blobStores.get(name);
+    if (existing)
+      return existing;
+    const created = new Map;
+    blobStores.set(name, created);
+    return created;
+  };
+  const blobsApi = (name) => {
+    const store = blobStore(name);
+    return {
+      async put(input) {
+        const id = crypto.randomUUID();
+        const data = input.data instanceof Uint8Array ? input.data : new Uint8Array(input.data);
+        const ref = {
+          id,
+          name: input.name,
+          mimeType: input.mimeType ?? null,
+          size: data.byteLength,
+          hash: null,
+          url: `memory://${id}`,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        };
+        store.set(id, { ...ref, data });
+        return ref;
+      },
+      async get(id) {
+        const stored = store.get(id);
+        if (!stored)
+          return;
+        const { data: _data, ...ref } = stored;
+        return ref;
+      },
+      async getBytes(id) {
+        const stored = store.get(id);
+        if (!stored)
+          throw new Error(`File not found: ${id}`);
+        return stored.data;
+      },
+      async list() {
+        return [...store.values()].map(({ data: _data, ...ref }) => ref);
+      },
+      async delete(id) {
+        store.delete(id);
+      },
+      urlFor(id) {
+        return `memory://${id}`;
+      }
+    };
+  };
+  const api = {
+    files: blobsApi("project"),
+    scope(_scope) {
+      return api;
+    },
+    async get(key) {
+      return kv.get(key);
+    },
+    async set(key, value) {
+      kv.set(key, value);
+    },
+    async delete(key) {
+      kv.delete(key);
+    },
+    collection(name) {
+      const store = collectionStore(name);
+      return {
+        async get(id) {
+          return store.get(id);
+        },
+        async list() {
+          return [...store.values()];
+        },
+        async put(id, value) {
+          store.set(id, value);
+        },
+        async createIfAbsent(id, value) {
+          if (store.has(id))
+            return false;
+          store.set(id, value);
+          return true;
+        },
+        async deleteIfValue(id, value) {
+          if (store.get(id) !== value && JSON.stringify(store.get(id)) !== JSON.stringify(value))
+            return false;
+          return store.delete(id);
+        },
+        async create(value) {
+          const id = crypto.randomUUID();
+          store.set(id, value);
+          return { ...typeof value === "object" && value !== null ? value : {}, id };
+        },
+        async delete(id) {
+          store.delete(id);
+        },
+        attachments(itemId) {
+          return blobsApi(`${name}:${itemId}`);
+        }
+      };
+    }
+  };
+  return api;
+};
+export {
+  commandParamsFor,
+  createMemoryRepoFiles,
+  createMemoryResources,
+  createMemoryStorage,
+  makeCommandArgs,
+  makeCommandContext
+};