@pstdio/sdk 0.19.0 → 0.21.0

package/dist/extensions/index.js

@@ -13,9 +13,51 @@ var __export = (target, all) => {
     });
 };
 
+// ../pstdio-api-contracts/src/extension-kernel/builtin-refs.ts
+var hostRef = (kind, id) => ({ extensionId: "pstdio", kind, id });
+var workbenchCommands = {
+  switchMode: hostRef("command", "workbench.action.switchMode")
+};
+var workbenchModes = {
+  project: hostRef("mode", "project"),
+  settings: hostRef("mode", "settings")
+};
+var hostResourceKind = (id, label, menuSlots) => ({
+  id,
+  ref: hostRef("resource-kind", id),
+  surface: "primary",
+  label,
+  menuSlots
+});
+var headerMenuSlots = [
+  { id: "headerPrimary", placement: "header-primary", access: "public" },
+  { id: "headerOverflow", placement: "header-overflow", access: "public" }
+];
+var workbenchResourceKindDefinitions = {
+  project: hostResourceKind("project", "Extension", headerMenuSlots),
+  session: hostResourceKind("session", "Session", headerMenuSlots),
+  workspace: hostResourceKind("workspace", "Workspace", headerMenuSlots)
+};
+var workbenchResourceKinds = {
+  project: workbenchResourceKindDefinitions.project.ref,
+  session: workbenchResourceKindDefinitions.session.ref,
+  workspace: workbenchResourceKindDefinitions.workspace.ref
+};
+var workbenchSlots = {
+  projectNavigation: hostRef("navigation-item", "project.navigation"),
+  projectSettings: hostRef("settings-panel", "project.settings"),
+  statusBarLeading: hostRef("status-bar-item", "status-bar.leading"),
+  statusBarTrailing: hostRef("status-bar-item", "status-bar.trailing")
+};
 // ../pstdio-api-contracts/src/extension-kernel/refs.ts
-var commandRef = (id) => ({ id });
-var eventRef = (id) => ({ id });
+var createCommandRef = (input) => ({ ...input, kind: "command" });
+var commandRef = Object.assign(createCommandRef, {
+  forExtension: (owner) => (id) => createCommandRef({ extensionId: `${owner.publisher}.${owner.name}`, id })
+});
+var eventRef = (input) => ({
+  ...input,
+  kind: "event"
+});
 
 // ../pstdio-api-contracts/src/extension-kernel/slots.ts
 var defineSlot = (id, options) => ({
@@ -27,48 +69,49 @@ var defineSlot = (id, options) => ({
 });
 
 // ../pstdio-api-contracts/src/extension-kernel/kernel-slots.ts
+var hostEventRef = (id) => eventRef({ extensionId: "pstdio", id });
+var resourceMenuSlotRef = (resourceKind, id) => defineSlot(`${resourceKind.id}.${id}`, { kind: "menu" });
 var projectSlots = {
   sidenav: defineSlot("project.sidenav", { kind: "panel" }),
-  headerPrimary: defineSlot("project.headerPrimary", { kind: "menu" }),
-  headerOverflow: defineSlot("project.headerOverflow", { kind: "menu" }),
+  headerPrimary: resourceMenuSlotRef(workbenchResourceKinds.project, "headerPrimary"),
+  headerOverflow: resourceMenuSlotRef(workbenchResourceKinds.project, "headerOverflow"),
   settingsPanels: defineSlot("project.settingsPanels", { kind: "settings" })
 };
 var sessionSlots = {
-  headerPrimary: defineSlot("session.headerPrimary", { kind: "menu" }),
-  headerOverflow: defineSlot("session.headerOverflow", { kind: "menu" }),
-  transcriptActions: defineSlot("session.transcriptActions", { kind: "menu" })
+  headerPrimary: resourceMenuSlotRef(workbenchResourceKinds.session, "headerPrimary"),
+  headerOverflow: resourceMenuSlotRef(workbenchResourceKinds.session, "headerOverflow")
 };
 var workspaceSlots = {
-  headerPrimary: defineSlot("workspace.headerPrimary", { kind: "menu" }),
-  headerOverflow: defineSlot("workspace.headerOverflow", { kind: "menu" }),
+  headerPrimary: resourceMenuSlotRef(workbenchResourceKinds.workspace, "headerPrimary"),
+  headerOverflow: resourceMenuSlotRef(workbenchResourceKinds.workspace, "headerOverflow"),
   sidenav: defineSlot("workspace.sidenav", { kind: "panel" })
 };
 var projectEvents = {
-  opened: eventRef("project.opened")
+  opened: hostEventRef("project.opened")
 };
 var sessionEvents = {
-  started: eventRef("session.started"),
-  resumed: eventRef("session.resumed"),
-  awaitingInput: eventRef("session.awaitingInput"),
-  succeeded: eventRef("session.succeeded"),
-  failed: eventRef("session.failed"),
-  completed: eventRef("session.completed")
+  started: hostEventRef("session.started"),
+  resumed: hostEventRef("session.resumed"),
+  awaitingInput: hostEventRef("session.awaitingInput"),
+  succeeded: hostEventRef("session.succeeded"),
+  failed: hostEventRef("session.failed"),
+  completed: hostEventRef("session.completed")
 };
 var workspaceEvents = {
-  created: eventRef("workspace.created"),
-  provision: eventRef("workspace.provision"),
-  ready: eventRef("workspace.ready"),
-  archived: eventRef("workspace.archived"),
-  deleted: eventRef("workspace.deleted")
+  created: hostEventRef("workspace.created"),
+  provision: hostEventRef("workspace.provision"),
+  ready: hostEventRef("workspace.ready"),
+  archived: hostEventRef("workspace.archived"),
+  deleted: hostEventRef("workspace.deleted")
 };
 var worktreeEvents = {
-  removed: eventRef("worktree.removed")
+  removed: hostEventRef("worktree.removed")
 };
 var gitEvents = {
-  committed: eventRef("git.committed"),
-  rebased: eventRef("git.rebased"),
-  merged: eventRef("git.merged"),
-  conflicted: eventRef("git.conflicted")
+  committed: hostEventRef("git.committed"),
+  rebased: hostEventRef("git.rebased"),
+  merged: hostEventRef("git.merged"),
+  conflicted: hostEventRef("git.conflicted")
 };
 // ../pstdio-api-contracts/src/extension-kernel/l10n.ts
 var l10n = (key, defaultValue) => ({
@@ -85,7 +128,7 @@ var packageAsset = (path, baseUrl) => ({
 // ../pstdio-api-contracts/src/extension-kernel/types/composition.ts
 var dockedWorkbenchRegions = ["sidenav", "main", "secondary", "side"];
 // ../pstdio-api-contracts/src/extension-kernel/types/extension.ts
-var EXTENSION_API_VERSION = "1.0.0-alpha.2";
+var EXTENSION_API_VERSION = "1.0.0-alpha.5";
 // ../pstdio-api-contracts/src/extension-kernel/types/webview-capabilities.ts
 var WEBVIEW_HOST_CAPABILITY_VERSION = 1;
 var WEBVIEW_DECLARABLE_CAPABILITIES = [
@@ -111,90 +154,6 @@ var WEBVIEW_HOST_CAPABILITIES = [
   ...WEBVIEW_DECLARABLE_CAPABILITIES,
   ...ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES
 ];
-// ../pstdio-api-contracts/src/extension-kernel/workbench-targets.ts
-var workbenchMenuTargets = ["workbench.nav.actions", "workbench.nav.overflow"];
-var workbenchTreeTargets = [
-  "workbench.left.tree",
-  "workbench.main.left.tree",
-  "workbench.main.right.tree"
-];
-var workbenchRegions = [
-  "nav",
-  "activity",
-  "sidenav-header",
-  "sidenav",
-  "main-header",
-  "main",
-  "secondary-header",
-  "secondary",
-  "side-header",
-  "side",
-  "status",
-  "overlay"
-];
-var workbenchViewTargets = [
-  "workbench.main",
-  "workbench.main.left",
-  "workbench.main.right",
-  "workbench.secondary"
-];
-var workbenchSettingsTargets = ["workbench.settings"];
-var workbenchSettingsScopes = ["project", "global"];
-var workbenchModePanels = ["main", "secondary", "side"];
-var workbenchModeLayoutTargets = [
-  "workbench.left",
-  "workbench.main.left",
-  "workbench.main",
-  "workbench.main.right",
-  "workbench.secondary"
-];
-var workbenchModeLayoutTargetPanels = {
-  "workbench.left": undefined,
-  "workbench.main.left": "main",
-  "workbench.main": "main",
-  "workbench.main.right": "main",
-  "workbench.secondary": "secondary"
-};
-var getWorkbenchModeLayoutTargetPanel = (target) => workbenchModeLayoutTargetPanels[target];
-var workbenchTargets = [
-  {
-    id: "workbench.nav.actions",
-    allowedKinds: ["menu"],
-    granularity: "surface",
-    rationale: "Primary command surface in the host-owned nav (top) workbench chrome."
-  },
-  {
-    id: "workbench.nav.overflow",
-    allowedKinds: ["menu"],
-    granularity: "surface",
-    rationale: "Secondary command surface in the host-owned nav (top) workbench chrome."
-  },
-  {
-    id: "workbench.left.tree",
-    allowedKinds: ["treeItem"],
-    granularity: "areaTree",
-    rationale: "Tree entries for the active tree renderer mounted in the left area."
-  },
-  {
-    id: "workbench.main.left.tree",
-    allowedKinds: ["treeItem"],
-    granularity: "areaTree",
-    rationale: "Tree entries for the active tree renderer mounted in the main-left area."
-  },
-  {
-    id: "workbench.main.right.tree",
-    allowedKinds: ["treeItem"],
-    granularity: "areaTree",
-    rationale: "Tree entries for the active tree renderer mounted in the main-right area."
-  },
-  {
-    id: "workbench.settings",
-    allowedKinds: ["settings"],
-    granularity: "surface",
-    rationale: "Settings panel placement in host-owned settings navigation."
-  }
-];
-var getWorkbenchTargetDefinition = (id) => workbenchTargets.find((target) => target.id === id);
 // src/extensions/command-outcome.ts
 var unwrapCommandOutcome = (response, fallbackReason = "Command failed.") => {
   const { outcome } = response;
@@ -204,9 +163,55 @@ var unwrapCommandOutcome = (response, fallbackReason = "Command failed.") => {
   return outcome.value;
 };
 // src/extensions/define-command.ts
-var defineCommand = (definition) => definition;
-var defineMiddleware = (definition) => definition;
-var defineHook = (definition) => definition;
+function defineCommand(definition) {
+  return { ...definition, ref: { kind: "command", id: definition.id } };
+}
+var defineMiddleware = (definition) => ({
+  ...definition,
+  ref: { kind: "middleware", id: definition.id }
+});
+var defineHook = (definition) => ({
+  ...definition,
+  ref: { kind: "hook", id: definition.id }
+});
+// src/extensions/define-contribution.ts
+var defineContribution = (_kind) => (definition) => ({
+  ...definition,
+  ref: { kind: _kind, id: definition.id }
+});
+var defineView = defineContribution("view");
+var defineViewMenu = defineContribution("view-menu");
+var definePlacement = defineContribution("placement");
+var defineResourceKind = defineContribution("resource-kind");
+var resourceSlotRef = (resourceKind, id) => ({
+  resourceKind,
+  id
+});
+var resourceMenuSlotRef2 = (resourceKind, id) => defineSlot(`${resourceKind.id}.${id}`, { kind: "menu" });
+var defineResourceView = defineContribution("resource-view");
+var defineNavigationItem = defineContribution("navigation-item");
+var defineMode = defineContribution("mode");
+var defineStatusBarItem = defineContribution("status-bar-item");
+var defineStatuses = defineContribution("status");
+var defineSettingsPanel = defineContribution("settings-panel");
+var defineActivityItem = defineContribution("activity-item");
+var defineSettingsSection = defineContribution("settings-section");
+var defineCommandPaletteResource = defineContribution("command-palette-resource");
+var defineKeybinding = defineContribution("keybinding");
+var defineSchedule = defineContribution("schedule");
+var defineArtifactMount = defineContribution("artifact-mount");
+var defineTemplateType = defineContribution("template-type");
+var defineTemplate = defineContribution("template");
+var defineSkill = defineContribution("skill");
+var defineTheme = defineContribution("theme");
+var defineFileIconTheme = defineContribution("file-icon-theme");
+var defineWorkspaceType = defineContribution("workspace-type");
+var defineHarness = defineContribution("harness");
+var defineConnection = defineContribution("connection");
+var defineResourceHierarchyProvider = (definition) => ({
+  ...definition,
+  ref: { kind: "resource-hierarchy-provider", id: definition.id }
+});
 // src/extensions/define-extension.ts
 var defineExtension = (extension) => extension;
 // src/extensions/define-extension-view.ts
@@ -288,21 +293,14 @@ var params = {
   }),
   repo: (options) => ({ type: "repo", ...options }),
   harness: (options) => ({ type: "harness", ...options }),
-  template: (options) => ({
-    label: options.label,
-    description: options.description,
-    required: options.required,
-    defaultValue: options.defaultValue,
-    metadata: options.metadata,
-    type: "template",
-    templateType: options.type
-  }),
   resource: (options) => ({ type: "resource", ...options }),
   json: (options) => ({ type: "json", ...options }),
   list: (options) => ({ type: "list", ...options })
 };
 // src/extensions/refs.ts
 var commandEvent = (command, phase) => ({
+  ...command.extensionId ? { extensionId: command.extensionId } : {},
+  kind: "event",
   id: `command.${phase}:${command.id}`
 });
 // src/extensions/terminal-session-bridge.ts
@@ -377,28 +375,56 @@ var createTerminalSessionBridge = (host) => ({
     };
   }
 });
+// src/extensions/webview-client.ts
+var createWebviewClient = (host, options) => {
+  const extensionId = options?.extensionId ?? host.extensionId;
+  if (!extensionId) {
+    throw new Error("The host bridge did not provide an extension id. Pass { extensionId } to createWebviewClient.");
+  }
+  const runCommand = async (commandKey, params2) => {
+    const response = await host.call("commands.execute", {
+      commandId: `${extensionId}.command.${commandKey}`,
+      params: params2
+    });
+    return unwrapCommandOutcome(response);
+  };
+  const commands = new Proxy({}, {
+    get: (_target, commandKey) => {
+      if (typeof commandKey !== "string")
+        return;
+      return (params2) => runCommand(commandKey, params2);
+    }
+  });
+  const settings = {
+    all: async () => await host.call("extension.settings.all", {}) ?? {},
+    get: (key) => host.call("extension.settings.get", { key }),
+    set: async (key, value) => {
+      await host.call("extension.settings.set", { key, value });
+    }
+  };
+  return { commands, settings };
+};
 // src/extensions/when.ts
 var matchesResourceWhen = (when, resourceType) => {
   const resourceTypes = when?.resourceType;
   if (!resourceTypes?.length)
     return true;
-  return resourceType ? resourceTypes.includes(resourceType) : false;
+  return resourceType ? resourceTypes.some((candidate) => (typeof candidate === "string" ? candidate : candidate.id) === resourceType) : false;
 };
 export {
   worktreeEvents,
   workspaceSlots,
   workspaceEvents,
-  workbenchViewTargets,
-  workbenchTreeTargets,
-  workbenchTargets,
-  workbenchSettingsTargets,
-  workbenchSettingsScopes,
-  workbenchModePanels,
-  workbenchModeLayoutTargets,
-  workbenchMenuTargets,
+  workbenchSlots,
+  workbenchResourceKinds,
+  workbenchResourceKindDefinitions,
+  workbenchModes,
+  workbenchCommands,
   unwrapCommandOutcome,
   sessionSlots,
   sessionEvents,
+  resourceSlotRef,
+  resourceMenuSlotRef2 as resourceMenuSlotRef,
   projectSlots,
   projectEvents,
   params,
@@ -407,15 +433,40 @@ export {
   l10n,
   isLocalizedString,
   gitEvents,
-  getWorkbenchTargetDefinition,
-  getWorkbenchModeLayoutTargetPanel,
   eventRef,
   dockedWorkbenchRegions,
+  defineWorkspaceType,
+  defineViewMenu,
+  defineView,
+  defineTheme,
+  defineTemplateType,
+  defineTemplate,
+  defineStatuses,
+  defineStatusBarItem,
+  defineSlot,
+  defineSkill,
+  defineSettingsSection,
+  defineSettingsPanel,
+  defineSchedule,
+  defineResourceView,
+  defineResourceKind,
+  defineResourceHierarchyProvider,
+  definePlacement,
+  defineNavigationItem,
+  defineMode,
   defineMiddleware,
+  defineKeybinding,
   defineHook,
+  defineHarness,
+  defineFileIconTheme,
   defineExtensionView,
   defineExtension,
+  defineConnection,
+  defineCommandPaletteResource,
   defineCommand,
+  defineArtifactMount,
+  defineActivityItem,
+  createWebviewClient,
   createTerminalSessionBridge,
   commandRef,
   commandEvent,

package/dist/extensions/params.d.ts

@@ -1,4 +1,4 @@
-import type { BooleanParam, FilesParam, HarnessParam, JsonParam, ListParam, LongTextParam, MarkdownParam, MultiSelectParam, NumberParam, RepoParam, ResourceParam, SelectParam, TemplateParam, TextParam } from "pstdio-api-contracts/extension-kernel";
+import type { BooleanParam, FilesParam, HarnessParam, JsonParam, ListParam, LongTextParam, MarkdownParam, MultiSelectParam, NumberParam, RepoParam, ResourceParam, SelectParam, TextParam } from "pstdio-api-contracts/extension-kernel";
 type RequiredOf<TOptions> = TOptions extends {
     required: infer TRequired extends boolean;
 } ? TRequired : undefined;
@@ -26,9 +26,6 @@ export declare const params: {
     multiSelect: <const TOptions extends ParamOptions<MultiSelectParam>>(options: TOptions) => MultiSelectParam<RequiredOf<TOptions>>;
     repo: <const TOptions extends ParamOptions<RepoParam> | undefined = undefined>(options?: TOptions) => RepoParam<RequiredOf<TOptions>>;
     harness: <const TOptions extends ParamOptions<HarnessParam> | undefined = undefined>(options?: TOptions) => HarnessParam<RequiredOf<TOptions>>;
-    template: <const TOptions extends Omit<TemplateParam, "type" | "templateType"> & {
-        type: string;
-    }>(options: TOptions) => TemplateParam<RequiredOf<TOptions>>;
     resource: <const TOptions extends ParamOptions<ResourceParam>>(options: TOptions) => ResourceParam<RequiredOf<TOptions>>;
     json: <T = unknown, const TOptions extends ParamOptions<JsonParam<T>> | undefined = undefined>(options?: TOptions) => JsonParam<T, RequiredOf<TOptions>>;
     list: <const TOptions extends ParamOptions<ListParam> | undefined = undefined>(options?: TOptions) => ListParam<RequiredOf<TOptions>>;

package/dist/extensions/react/index.d.ts

@@ -0,0 +1,16 @@
+import { type QueryKey } from "@tanstack/react-query";
+interface CommandQueryInput<TResult> {
+    queryKey: QueryKey;
+    command: () => Promise<TResult>;
+    enabled?: boolean;
+    staleTime?: number;
+}
+/** Reads server state via a typed client command, cached and deduped by react-query. */
+export declare const useCommandQuery: <TResult>(input: CommandQueryInput<TResult>) => import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TResult>, Error>;
+interface CommandMutationInput<TParams, TResult> {
+    command: (params: TParams) => Promise<TResult>;
+    invalidate?: QueryKey[];
+}
+/** Writes server state via a typed client command and refreshes affected queries on success. */
+export declare const useCommandMutation: <TParams, TResult>(input: CommandMutationInput<TParams, TResult>) => import("@tanstack/react-query").UseMutationResult<TResult, Error, TParams, unknown>;
+export {};

package/dist/extensions/react/index.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/extensions/react/index.ts
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+var useCommandQuery = (input) => {
+  const { command, enabled, queryKey, staleTime } = input;
+  return useQuery({
+    queryKey,
+    enabled,
+    staleTime,
+    queryFn: () => command()
+  });
+};
+var useCommandMutation = (input) => {
+  const { command, invalidate } = input;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (params) => command(params),
+    onSuccess: () => invalidate?.forEach((queryKey) => void queryClient.invalidateQueries({ queryKey }))
+  });
+};
+export {
+  useCommandQuery,
+  useCommandMutation
+};

package/dist/extensions/webview-client.d.ts

@@ -0,0 +1,41 @@
+import type { CommandDefinition, ParamObjectSchema, ParamsOf } from "pstdio-api-contracts/extension-kernel";
+import type { SettingsMap } from "./define-extension";
+import type { GuestHost } from "./define-extension-view";
+type CommandFn<TDefinition> = TDefinition extends CommandDefinition<infer TSchema, infer TResult, infer _TSettings> ? TSchema extends ParamObjectSchema ? Partial<ParamsOf<TSchema>> extends ParamsOf<TSchema> ? (params?: ParamsOf<TSchema>) => Promise<TResult> : (params: ParamsOf<TSchema>) => Promise<TResult> : () => Promise<TResult> : never;
+export type WebviewCommandsClient<TCommands> = {
+    [K in keyof TCommands & string]: CommandFn<TCommands[K]>;
+};
+export type WebviewSettingsClient<TSettings> = {
+    all: () => Promise<Partial<TSettings>>;
+    get: <K extends keyof TSettings & string>(key: K) => Promise<TSettings[K] | undefined>;
+    set: <K extends keyof TSettings & string>(key: K, value: TSettings[K]) => Promise<void>;
+};
+type ClientSettingsMap<TSettings> = TSettings extends {
+    properties: unknown;
+} ? SettingsMap<TSettings> : Record<never, never>;
+export type WebviewClient<TCommands, TSettings = undefined> = {
+    commands: WebviewCommandsClient<TCommands>;
+    settings: WebviewSettingsClient<ClientSettingsMap<TSettings>>;
+};
+export interface WebviewClientOptions {
+    /** Overrides the extension id provided by the host bridge (e.g. in tests). */
+    extensionId?: string;
+}
+/**
+ * Typed guest-side client over the host bridge. Command params and results come from
+ * the extension's exported commands record (`defineCommand` values); settings come
+ * from its exported settings contribution. Command outcomes are unwrapped, so
+ * failures throw.
+ *
+ * Import both as types only, so no server code enters the webview bundle:
+ *
+ * @example
+ *   import type { commands } from "../commands";
+ *   import type { settings } from "../settings";
+ *
+ *   const client = createWebviewClient<typeof commands, typeof settings>(host);
+ *   const { statuses } = await client.commands["ticketStatus.read"]();
+ *   const enabled = await client.settings.get("counter.enabled");
+ */
+export declare const createWebviewClient: <TCommands extends object, TSettings = undefined>(host: GuestHost, options?: WebviewClientOptions) => WebviewClient<TCommands, TSettings>;
+export {};

package/dist/extensions/when.d.ts

@@ -6,4 +6,6 @@ import type { WhenExpression } from "pstdio-api-contracts/extension-kernel";
  * resolve from the active resource alone (`mode`/`source`/`metadata` require execution context the
  * palette does not have).
  */
-export declare const matchesResourceWhen: (when: Pick<WhenExpression, "resourceType"> | undefined, resourceType: string | undefined) => boolean;
+export declare const matchesResourceWhen: (when: Pick<WhenExpression, "resourceType"> | {
+    resourceType?: readonly string[];
+} | undefined, resourceType: string | undefined) => boolean;

package/dist/resources/index.d.ts

@@ -6,5 +6,4 @@ export type { Project } from "./project";
 export type { Session, SessionStatus } from "./session";
 export type { Settings } from "./settings";
 export type { Skill, SkillFile, SkillWithContent } from "./skill";
-export type { Template, TemplateType, TemplateWithContent } from "./template";
 export type { Workspace, WorkspaceListItem } from "./workspace";