@pstdio/sdk 0.6.0 → 0.8.0

package/dist/api/extensions.d.ts

@@ -1 +1 @@
-export type { UpdateInstalledExtensionTemplateInput, UpdateInstalledExtensionTemplateResponse, } from "pstdio-api-contracts";
+export type { CommandExecuteRequest, CommandExecuteResponse, DashboardExtensionMetadata, ExtensionCommandRecord, ExtensionDiagnostic, ExtensionMenuContribution, ExtensionNavigationRecord, ExtensionRecord, ExtensionRouteRecord, ExtensionSettingsPanelRecord, ExtensionViewRecord, ListExtensionAppearanceResponse, ListExtensionCommandsResponse, ListProjectExtensionsResponse, ProjectExtensionInstance, UpdateInstalledExtensionTemplateInput, UpdateInstalledExtensionTemplateResponse, } from "pstdio-api-contracts";

package/dist/api/index.d.ts

@@ -1,8 +1,9 @@
 export type { ActionResult, ExecuteActionInput } from "./actions";
 export type { SetupAgentInput, SetupAvailableAgentsInput, UpdateAgentInput } from "./agents";
-export type { UpdateInstalledExtensionTemplateInput, UpdateInstalledExtensionTemplateResponse } from "./extensions";
+export type { CommandExecuteRequest, CommandExecuteResponse, DashboardExtensionMetadata, ExtensionCommandRecord, ExtensionDiagnostic, ExtensionMenuContribution, ExtensionNavigationRecord, ExtensionRecord, ExtensionRouteRecord, ExtensionSettingsPanelRecord, ExtensionViewRecord, ListExtensionAppearanceResponse, ListExtensionCommandsResponse, ListProjectExtensionsResponse, ProjectExtensionInstance, UpdateInstalledExtensionTemplateInput, UpdateInstalledExtensionTemplateResponse, } from "./extensions";
 export type { CreateProjectInput, RegisterRepoInput } from "./projects";
 export type { ApprovalInput, CreateSessionInput, FollowUpInput, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse, } from "./sessions";
+export type { Settings, UpdateSettingsInput } from "./settings";
 export type { UpdateSkillInput } from "./skills";
 export type { CreateAttemptStatusInput, CreateStatusInput } from "./statuses";
 export type { CreateTagInput, CreateTagOptionInput, UpdateTagInput, UpdateTagOptionInput } from "./tags";

package/dist/api/sessions.d.ts

@@ -1 +1 @@
-export type { ApprovalInput, CreateSessionInput, FollowUpInput, ListSessionActivityInput, ListSessionActivityResponse, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse, } from "pstdio-api-contracts";
+export type { ApprovalInput, CreateSessionInput, FollowUpDecision, FollowUpInput, FollowUpResponse, ListSessionActivityInput, ListSessionActivityResponse, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse, } from "pstdio-api-contracts";

package/dist/api/settings.d.ts

@@ -0,0 +1 @@
+export type { Settings, UpdateSettingsInput } from "pstdio-api-contracts";

package/dist/client/client.d.ts

@@ -4,8 +4,10 @@ import { type ExtensionClient } from "./extensions";
 import { type ProjectClient } from "./projects";
 import type { ClientOptions } from "./request";
 import { type SessionClient } from "./sessions";
+import { type SettingsClient } from "./settings";
 import { type SkillClient } from "./skills";
 import { type StatusClient } from "./statuses";
+import { type SyncClient } from "./sync";
 import { type TagClient } from "./tags";
 import { type TemplateClient } from "./templates";
 import { type TicketClient } from "./tickets";
@@ -22,5 +24,7 @@ export type PstdioClient = {
     agents: AgentClient;
     actions: ActionClient;
     extensions: ExtensionClient;
+    settings: SettingsClient;
+    sync: SyncClient;
 };
 export declare const createClient: (options?: ClientOptions) => PstdioClient;

package/dist/client/index.d.ts

@@ -3,10 +3,13 @@ export type { AgentClient } from "./agents";
 export { createClient, type PstdioClient } from "./client";
 export type { ExtensionClient } from "./extensions";
 export type { ProjectClient } from "./projects";
-export { type ClientOptions, createRequest, PstdioApiError, type RequestFn } from "./request";
-export type { SessionClient } from "./sessions";
+export { type ClientOptions, createRequest, PstdioApiError, type RequestFn, type RequestOptions, } from "./request";
+export type { ListSessionsInput, SessionClient, SessionStreamConnection, SessionStreamHandlers } from "./sessions";
+export type { SettingsClient } from "./settings";
 export type { SkillClient } from "./skills";
+export type { SseEvent } from "./sse";
 export type { StatusClient } from "./statuses";
+export { applySyncEvent, parseSyncDeleteEvent, type StartSyncInput, type SyncClient, type SyncConnection, type SyncRow, type SyncWriter, type SyncWriterProvider, } from "./sync";
 export type { TagClient } from "./tags";
 export type { TemplateClient } from "./templates";
 export type { TicketClient } from "./tickets";

package/dist/client/index.js

@@ -107,20 +107,32 @@ ${hookOutput}` : message;
   }
   return `Request failed: ${status}`;
 };
+var resolveBaseUrl = (options) => options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
+var resolveClientUrl = (baseUrl, path) => path.startsWith("http://") || path.startsWith("https://") ? path : `${baseUrl}${path}`;
+var resolveFetch = (options) => options.fetch ?? globalThis.fetch;
+var createRequestHeaders = (options, reqOpts = {}) => {
+  const headers = new Headers(reqOpts.headers);
+  if (reqOpts.hasJsonBody && !headers.has("content-type"))
+    headers.set("content-type", "application/json");
+  if (options.token)
+    headers.set("authorization", `Bearer ${options.token}`);
+  return headers;
+};
 var createRequest = (options) => {
-  const baseUrl = options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
-  const fetchFn = options.fetch ?? globalThis.fetch;
+  const baseUrl = resolveBaseUrl(options);
+  const fetchFn = resolveFetch(options);
   return async (path, reqOpts = {}) => {
-    const headers = {};
-    if (reqOpts.body !== undefined)
-      headers["content-type"] = "application/json";
-    if (options.token)
-      headers.authorization = `Bearer ${options.token}`;
-    const response = await fetchFn(`${baseUrl}${path}`, {
+    const headers = createRequestHeaders(options, {
+      headers: reqOpts.headers,
+      hasJsonBody: reqOpts.body !== undefined
+    });
+    const url = resolveClientUrl(baseUrl, path);
+    const response = await fetchFn(url, {
       method: reqOpts.method ?? "GET",
-      headers,
+      headers: Object.fromEntries(headers.entries()),
       body: reqOpts.body !== undefined ? JSON.stringify(reqOpts.body) : undefined,
-      signal: reqOpts.signal
+      signal: reqOpts.signal,
+      cache: reqOpts.cache
     });
     if (!response.ok) {
       const errorBody = await response.json().catch(() => null);
@@ -133,8 +145,105 @@ var createRequest = (options) => {
   };
 };
 
+// src/client/sse.ts
+var parseSseEvent = (part) => {
+  let event = "message";
+  const data = [];
+  for (const line of part.split(`
+`)) {
+    if (line.startsWith("event: ")) {
+      event = line.slice(7);
+      continue;
+    }
+    if (line.startsWith("data: ")) {
+      data.push(line.slice(6));
+    }
+  }
+  if (!event || data.length === 0)
+    return null;
+  return { event, data: data.join(`
+`) };
+};
+var consumeSseBuffer = (buffer) => {
+  const parts = buffer.split(`
+
+`);
+  const remainder = parts.pop() ?? "";
+  const events = parts.map((part) => parseSseEvent(part)).filter((event) => event !== null);
+  return { remainder, events };
+};
+var readSseStream = async (body, onEvent, options = {}) => {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  const abort = () => {
+    reader.cancel();
+  };
+  options.signal?.addEventListener("abort", abort, { once: true });
+  try {
+    while (!options.signal?.aborted) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const { remainder, events } = consumeSseBuffer(buffer);
+      buffer = remainder;
+      for (const event of events) {
+        onEvent(event);
+      }
+    }
+  } finally {
+    options.signal?.removeEventListener("abort", abort);
+  }
+};
+
 // src/client/sessions.ts
-var createSessionClient = (request) => ({
+var buildSessionsQuery = (projectId, input = {}) => {
+  const params = new URLSearchParams({ project_id: projectId });
+  if (input.status)
+    params.append("status", input.status);
+  if (input.agent)
+    params.append("agent", input.agent);
+  if (input.archived)
+    params.append("archived", "true");
+  return params.toString();
+};
+var buildSessionStreamPath = (sessionId, attempt) => {
+  const path = `/v1/sessions/${sessionId}/stream`;
+  return attempt === undefined ? path : `${path}?attempt=${attempt}`;
+};
+var parseEventData = (data) => {
+  if (data.length === 0)
+    return null;
+  return JSON.parse(data);
+};
+var streamSessionEvents = async (clientOptions, path, onEvent, options = {}) => {
+  const response = await resolveFetch(clientOptions)(resolveClientUrl(resolveBaseUrl(clientOptions), path), {
+    headers: Object.fromEntries(createRequestHeaders(clientOptions).entries()),
+    signal: options.signal
+  });
+  if (!response.ok || !response.body)
+    throw new Error(`Connection failed: ${response.status}`);
+  await readSseStream(response.body, onEvent, { signal: options.signal });
+};
+var dispatchSessionStreamEvent = (event, handlers) => {
+  if (event.event === "ready") {
+    handlers.onReady?.(parseEventData(event.data));
+    return;
+  }
+  if (event.event === "patch") {
+    handlers.onPatch?.(parseEventData(event.data));
+    return;
+  }
+  if (event.event === "approval_request") {
+    handlers.onApprovalRequest?.(parseEventData(event.data));
+    return;
+  }
+  if (event.event === "end") {
+    handlers.onEnd?.(parseEventData(event.data));
+  }
+};
+var createSessionClient = (request, clientOptions) => ({
   listActivity: (sessionId, input = {}) => {
     const params = new URLSearchParams;
     if (input.event_type)
@@ -150,7 +259,7 @@ var createSessionClient = (request) => ({
     const query = params.toString();
     return request(`/v1/sessions/${sessionId}/activity${query ? `?${query}` : ""}`);
   },
-  list: (projectId) => request(`/v1/sessions?project_id=${projectId}`),
+  list: (projectId, input) => request(`/v1/sessions?${buildSessionsQuery(projectId, input)}`),
   get: (sessionId) => request(`/v1/sessions/${sessionId}`),
   create: (input) => request("/v1/sessions", { method: "POST", body: input }),
   archive: (sessionId) => request(`/v1/sessions/${sessionId}/archive`, { method: "POST" }),
@@ -158,7 +267,29 @@ var createSessionClient = (request) => ({
   approve: (sessionId, input) => request(`/v1/sessions/${sessionId}/approve`, { method: "POST", body: input }),
   getConversation: (sessionId) => request(`/v1/sessions/${sessionId}/conversation`),
   resolveSessionId: (input) => request("/v1/sessions/resolve-session-id", { method: "POST", body: input }),
-  updateStatus: (sessionId, status) => request(`/v1/sessions/${sessionId}/status`, { method: "PATCH", body: { status } })
+  updateStatus: (sessionId, status) => request(`/v1/sessions/${sessionId}/status`, { method: "PATCH", body: { status } }),
+  stream: (sessionId, onEvent, options = {}) => streamSessionEvents(clientOptions, buildSessionStreamPath(sessionId), onEvent, options),
+  connectStream: (sessionId, handlers, options = {}) => {
+    const abortController = new AbortController;
+    let closed = false;
+    streamSessionEvents(clientOptions, buildSessionStreamPath(sessionId, options.attempt), (event) => dispatchSessionStreamEvent(event, handlers), { signal: abortController.signal }).catch((error) => {
+      if (closed || error.name === "AbortError")
+        return;
+      handlers.onError?.(error);
+    });
+    return {
+      close: () => {
+        closed = true;
+        abortController.abort();
+      }
+    };
+  }
+});
+
+// src/client/settings.ts
+var createSettingsClient = (request) => ({
+  get: () => request("/v1/settings"),
+  update: (input) => request("/v1/settings", { method: "PATCH", body: input })
 });
 
 // src/client/skills.ts
@@ -181,6 +312,137 @@ var createStatusClient = (request) => ({
   deleteAttemptStatus: (projectId, statusId) => request(`/v1/projects/${projectId}/attempt-statuses/${statusId}`, { method: "DELETE" })
 });
 
+// src/client/sync.ts
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
+var DEFAULT_HEARTBEAT_THRESHOLD = 3;
+var DEFAULT_RECONNECT_DELAY_MS = 1000;
+var parseSyncDeleteEvent = (data) => {
+  const parsed = JSON.parse(data);
+  const id = parsed.id ?? parsed.data?.id;
+  if (!id) {
+    throw new Error("Missing id in sync:delete event.");
+  }
+  return {
+    table: parsed.table,
+    id,
+    seq: parsed.seq
+  };
+};
+var applySyncEvent = (event, data, writers) => {
+  if (event === "init") {
+    const parsed = JSON.parse(data);
+    for (const [table, rows] of Object.entries(parsed.tables)) {
+      writers.getWriter(table)?.truncateAndWrite(rows);
+    }
+    return parsed.seq;
+  }
+  if (event === "sync:set") {
+    const parsed = JSON.parse(data);
+    writers.getWriter(parsed.table)?.upsert(parsed.data);
+    return parsed.seq;
+  }
+  if (event === "sync:delete") {
+    const parsed = parseSyncDeleteEvent(data);
+    writers.getWriter(parsed.table)?.remove(parsed.id);
+    return parsed.seq;
+  }
+  if (event === "heartbeat") {
+    return JSON.parse(data).seq;
+  }
+  return null;
+};
+var createHeartbeatMonitor = (input) => {
+  let missedHeartbeats = 0;
+  let timer = null;
+  return {
+    recordHeartbeat: () => {
+      missedHeartbeats = 0;
+    },
+    start: () => {
+      timer = setInterval(() => {
+        missedHeartbeats += 1;
+        if (missedHeartbeats >= input.threshold) {
+          input.onConnectionLost?.();
+        }
+      }, input.intervalMs);
+    },
+    stop: () => {
+      if (timer)
+        clearInterval(timer);
+      timer = null;
+    }
+  };
+};
+var buildSyncStreamPath = (lastSeq) => lastSeq > 0 ? `/v1/sync/stream?since=${lastSeq}` : "/v1/sync/stream";
+var createSyncClient = (clientOptions) => ({
+  start: (input) => {
+    let lastSeq = 0;
+    let abortController = null;
+    let reconnectTimer = null;
+    let closed = false;
+    const state = { close: () => {}, connected: false };
+    const heartbeatMonitor = createHeartbeatMonitor({
+      intervalMs: input.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS,
+      threshold: input.heartbeatThreshold ?? DEFAULT_HEARTBEAT_THRESHOLD,
+      onConnectionLost: input.onConnectionLost
+    });
+    const setConnected = () => {
+      const wasConnected = state.connected;
+      state.connected = true;
+      if (!wasConnected)
+        input.onConnected?.();
+    };
+    const setDisconnected = () => {
+      const wasConnected = state.connected;
+      state.connected = false;
+      if (wasConnected)
+        input.onDisconnected?.();
+    };
+    const handleEvent = (event, data) => {
+      heartbeatMonitor.recordHeartbeat();
+      const nextSeq = applySyncEvent(event, data, input);
+      if (nextSeq !== null)
+        lastSeq = Math.max(lastSeq, nextSeq);
+      if (event === "init")
+        setConnected();
+    };
+    const connect = async () => {
+      if (closed)
+        return;
+      abortController = new AbortController;
+      try {
+        const response = await resolveFetch(clientOptions)(resolveClientUrl(resolveBaseUrl(clientOptions), buildSyncStreamPath(lastSeq)), {
+          headers: Object.fromEntries(createRequestHeaders(clientOptions).entries()),
+          signal: abortController.signal
+        });
+        if (!response.ok || !response.body)
+          throw new Error("SSE connection failed");
+        await readSseStream(response.body, ({ event, data }) => handleEvent(event, data), {
+          signal: abortController.signal
+        });
+      } catch (err) {
+        if (closed || err.name === "AbortError")
+          return;
+      }
+      if (closed)
+        return;
+      setDisconnected();
+      reconnectTimer = setTimeout(connect, input.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS);
+    };
+    heartbeatMonitor.start();
+    connect();
+    state.close = () => {
+      closed = true;
+      state.connected = false;
+      heartbeatMonitor.stop();
+      abortController?.abort();
+      if (reconnectTimer)
+        clearTimeout(reconnectTimer);
+    };
+    return state;
+  }
+});
+
 // src/client/tags.ts
 var createTagClient = (request) => ({
   list: (projectId) => request(`/v1/projects/${projectId}/ticket-tags`),
@@ -202,7 +464,7 @@ var createTemplateClient = (request) => ({
 });
 
 // src/client/tickets.ts
-var resolveBaseUrl = (options) => options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
+var resolveBaseUrl2 = (options) => options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
 var readErrorMessage2 = async (response) => {
   const errorBody = await response.json().catch(() => null);
   if (errorBody && typeof errorBody === "object" && errorBody !== null && "error" in errorBody) {
@@ -265,13 +527,13 @@ var createTicketClient = (request, options = {}) => ({
   },
   updateWhenAttemptStatus: (ticketId, input) => request(`/v1/tickets/${ticketId}/update-when-attempt-status`, { method: "POST", body: input }),
   listFiles: (ticketId) => request(`/v1/tickets/${ticketId}/files`),
-  getFileContent: async (ticketId, fileId) => {
-    const baseUrl = resolveBaseUrl(options);
+  getFileContent: async (ticketId, fileId, requestOptions = {}) => {
+    const baseUrl = resolveBaseUrl2(options);
     const fetchFn = options.fetch ?? globalThis.fetch;
     const headers = {};
     if (options.token)
       headers.authorization = `Bearer ${options.token}`;
-    const response = await fetchFn(`${baseUrl}/v1/tickets/${encodeURIComponent(ticketId)}/files/${encodeURIComponent(fileId)}/content`, { headers });
+    const response = await fetchFn(`${baseUrl}/v1/tickets/${encodeURIComponent(ticketId)}/files/${encodeURIComponent(fileId)}/content`, { cache: requestOptions.cache, headers, signal: requestOptions.signal });
     if (!response.ok) {
       throw new PstdioApiError(await readErrorMessage2(response), response.status);
     }
@@ -313,18 +575,22 @@ var createClient = (options = {}) => {
     projects: createProjectClient(request),
     tickets: createTicketClient(request, options),
     workspaces: createWorkspaceClient(request),
-    sessions: createSessionClient(request),
+    sessions: createSessionClient(request, options),
     statuses: createStatusClient(request),
     tags: createTagClient(request),
     templates: createTemplateClient(request),
     skills: createSkillClient(request),
     agents: createAgentClient(request),
     actions: createActionClient(request),
-    extensions: createExtensionClient(request)
+    extensions: createExtensionClient(request),
+    settings: createSettingsClient(request),
+    sync: createSyncClient(options)
   };
 };
 export {
+  parseSyncDeleteEvent,
   createRequest,
   createClient,
+  applySyncEvent,
   PstdioApiError
 };

package/dist/client/request.d.ts

@@ -11,6 +11,15 @@ export type RequestOptions = {
     method?: string;
     body?: unknown;
     signal?: AbortSignal;
+    headers?: HeadersInit;
+    cache?: RequestCache;
 };
 export type RequestFn = <T>(path: string, options?: RequestOptions) => Promise<T>;
+export declare const resolveBaseUrl: (options: ClientOptions) => string;
+export declare const resolveClientUrl: (baseUrl: string, path: string) => string;
+export declare const resolveFetch: (options: ClientOptions) => typeof fetch;
+export declare const createRequestHeaders: (options: ClientOptions, reqOpts?: {
+    headers?: HeadersInit;
+    hasJsonBody?: boolean;
+}) => Headers;
 export declare const createRequest: (options: ClientOptions) => RequestFn;

package/dist/client/sessions.d.ts

@@ -1,16 +1,38 @@
-import type { ApprovalInput, CreateSessionInput, FollowUpInput, ListSessionActivityInput, ListSessionActivityResponse, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse } from "pstdio-api-contracts";
+import type { ApprovalInput, CreateSessionInput, FollowUpInput, FollowUpResponse, ListSessionActivityInput, ListSessionActivityResponse, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse } from "pstdio-api-contracts";
 import type { Session } from "../resources";
-import type { RequestFn } from "./request";
+import { type ClientOptions, type RequestFn } from "./request";
+import { type SseEvent } from "./sse";
+export type ListSessionsInput = {
+    status?: string;
+    agent?: string;
+    archived?: boolean;
+};
 export type SessionClient = {
-    list(projectId: string): Promise<Session[]>;
+    list(projectId: string, input?: ListSessionsInput): Promise<Session[]>;
     get(sessionId: string): Promise<Session>;
     create(input: CreateSessionInput): Promise<Session>;
     archive(sessionId: string): Promise<void>;
-    followUp(sessionId: string, input: FollowUpInput): Promise<Session>;
+    followUp(sessionId: string, input: FollowUpInput): Promise<FollowUpResponse>;
     approve(sessionId: string, input: ApprovalInput): Promise<void>;
     getConversation(sessionId: string): Promise<SessionConversationResponse>;
     resolveSessionId(input: ResolveSessionIdInput): Promise<ResolveSessionIdResponse>;
     updateStatus(sessionId: string, status: string): Promise<Session>;
     listActivity(sessionId: string, input?: ListSessionActivityInput): Promise<ListSessionActivityResponse>;
+    stream(sessionId: string, onEvent: (event: SseEvent) => void, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    connectStream(sessionId: string, handlers: SessionStreamHandlers, options?: {
+        attempt?: number;
+    }): SessionStreamConnection;
+};
+export type SessionStreamHandlers = {
+    onReady?: (data: unknown) => void;
+    onPatch?: (data: unknown) => void;
+    onApprovalRequest?: (data: unknown) => void;
+    onEnd?: (data: unknown) => void;
+    onError?: (error: unknown) => void;
+};
+export type SessionStreamConnection = {
+    close: () => void;
 };
-export declare const createSessionClient: (request: RequestFn) => SessionClient;
+export declare const createSessionClient: (request: RequestFn, clientOptions: ClientOptions) => SessionClient;

package/dist/client/settings.d.ts

@@ -0,0 +1,7 @@
+import type { Settings, UpdateSettingsInput } from "../api/settings";
+import type { RequestFn } from "./request";
+export type SettingsClient = {
+    get(): Promise<Settings>;
+    update(input: UpdateSettingsInput): Promise<Settings>;
+};
+export declare const createSettingsClient: (request: RequestFn) => SettingsClient;

package/dist/client/sse.d.ts

@@ -0,0 +1,15 @@
+export type SseEvent = {
+    event: string;
+    data: string;
+};
+export declare const parseSseEvent: (part: string) => {
+    event: string;
+    data: string;
+} | null;
+export declare const consumeSseBuffer: (buffer: string) => {
+    remainder: string;
+    events: SseEvent[];
+};
+export declare const readSseStream: (body: ReadableStream<Uint8Array>, onEvent: (event: SseEvent) => void, options?: {
+    signal?: AbortSignal;
+}) => Promise<void>;

package/dist/client/sync.d.ts

@@ -0,0 +1,35 @@
+import { type ClientOptions } from "./request";
+export type SyncRow = {
+    id: string;
+    [key: string]: unknown;
+};
+export type SyncWriter = {
+    truncateAndWrite: (rows: SyncRow[]) => void;
+    upsert: (row: SyncRow) => void;
+    remove: (id: string) => void;
+};
+export type SyncWriterProvider = {
+    getWriter: (table: string) => SyncWriter | undefined;
+};
+export type SyncConnection = {
+    close: () => void;
+    connected: boolean;
+};
+export type StartSyncInput = SyncWriterProvider & {
+    onConnected?: () => void;
+    onDisconnected?: () => void;
+    onConnectionLost?: () => void;
+    heartbeatIntervalMs?: number;
+    heartbeatThreshold?: number;
+    reconnectDelayMs?: number;
+};
+export type SyncClient = {
+    start: (input: StartSyncInput) => SyncConnection;
+};
+export declare const parseSyncDeleteEvent: (data: string) => {
+    table: string;
+    id: string;
+    seq: number;
+};
+export declare const applySyncEvent: (event: string, data: string, writers: SyncWriterProvider) => number | null;
+export declare const createSyncClient: (clientOptions: ClientOptions) => SyncClient;

package/dist/client/tickets.d.ts

@@ -12,7 +12,10 @@ export type TicketClient = {
     listProjectActivity(projectId: string, input?: ListProjectActivityForTicketsInput): Promise<ListTicketActivityResponse>;
     updateWhenAttemptStatus(ticketId: string, input: UpdateWhenAttemptStatusInput): Promise<UpdateWhenAttemptStatusResponse>;
     listFiles(ticketId: string): Promise<TicketFile[]>;
-    getFileContent(ticketId: string, fileId: string): Promise<Uint8Array>;
+    getFileContent(ticketId: string, fileId: string, options?: {
+        cache?: RequestCache;
+        signal?: AbortSignal;
+    }): Promise<Uint8Array>;
     uploadFile(ticketId: string, input: UploadTicketFileInput): Promise<TicketFile>;
     deleteFile(ticketId: string, fileId: string): Promise<void>;
 };

package/dist/extensions/index.d.ts

@@ -1,7 +1,7 @@
 export { defineCommand, defineHook, defineMiddleware } from "./define-command";
 export { defineExtension } from "./define-extension";
 export { defineExtensionView, type ExtensionViewModule, type ExtensionViewRender, type ExtensionViewRenderContext, type GuestHost, type PropsStore, } from "./define-extension-view";
-export { projectEvents, projectSlots, sessionEvents, sessionSlots, workspaceEvents, workspaceSlots, } from "./kernel-slots";
+export { attemptStatusEvents, gitEvents, projectEvents, projectSlots, sessionEvents, sessionSlots, ticketEvents, workspaceCommands, workspaceEvents, workspaceSlots, worktreeEvents, } from "./kernel-slots";
 export { packageAsset } from "./package-asset";
 export { params } from "./params";
 export { commandEvent, commandRef, commandsOf, eventRef } from "./refs";

package/dist/extensions/index.js

@@ -60,13 +60,39 @@ var projectEvents = {
 };
 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")
 };
+var ticketEvents = {
+  created: eventRef("ticket.created"),
+  statusChanged: eventRef("ticket.statusChanged"),
+  archived: eventRef("ticket.archived"),
+  deleted: eventRef("ticket.deleted")
+};
 var workspaceEvents = {
   created: eventRef("workspace.created"),
   archived: eventRef("workspace.archived"),
   deleted: eventRef("workspace.deleted")
 };
+var worktreeEvents = {
+  created: eventRef("worktree.created"),
+  removed: eventRef("worktree.removed")
+};
+var gitEvents = {
+  committed: eventRef("git.committed"),
+  rebased: eventRef("git.rebased"),
+  merged: eventRef("git.merged"),
+  conflicted: eventRef("git.conflicted")
+};
+var attemptStatusEvents = {
+  changed: eventRef("attemptStatus.changed")
+};
+var workspaceCommands = {
+  setAttemptStatus: commandRef("kernel.workspace.setAttemptStatus")
+};
 // src/extensions/package-asset.ts
 var packageAsset = (path, baseUrl) => ({
   kind: "package-asset",
@@ -115,14 +141,18 @@ var WEBVIEW_HOST_CAPABILITIES = [
   ...ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES
 ];
 export {
+  worktreeEvents,
   workspaceSlots,
   workspaceEvents,
+  workspaceCommands,
+  ticketEvents,
   sessionSlots,
   sessionEvents,
   projectSlots,
   projectEvents,
   params,
   packageAsset,
+  gitEvents,
   eventRef,
   defineSlot,
   defineMiddleware,
@@ -133,6 +163,7 @@ export {
   commandsOf,
   commandRef,
   commandEvent,
+  attemptStatusEvents,
   WEBVIEW_HOST_CAPABILITY_VERSION,
   WEBVIEW_HOST_CAPABILITIES,
   WEBVIEW_DECLARABLE_CAPABILITIES,

package/dist/extensions/kernel-slots.d.ts

@@ -1,5 +1,101 @@
+import type { SetAttemptStatusInput, SetAttemptStatusResult } from "./types/context";
 import type { JsonObject } from "./types/json";
 import type { ResourceAnchor } from "./types/resources";
+export interface TicketArchivedEventPayload {
+    projectId: string;
+    ticket: {
+        id: string;
+        shorthand: string;
+        displayTitle: string | null;
+        userPrompt: string | null;
+        parentId: string | null;
+        draft: boolean;
+        archived: boolean;
+        status: string | null;
+        tagIds: string[];
+        tagNames: string[];
+        fileIds: string[];
+    };
+}
+export interface WorktreeCreatedEventPayload {
+    projectId: string;
+    repoPath: string;
+    worktreePath: string;
+    branch: string;
+    workspace: string;
+    workspaceId: string;
+    ticket: string;
+}
+export interface TicketLifecyclePayload {
+    projectId: string;
+    ticket: JsonObject;
+}
+export interface TicketStatusChangePayload {
+    projectId: string;
+    ticket: JsonObject;
+    fromStatus: string | null;
+    toStatus: string;
+}
+export interface AttemptStatusChangePayload {
+    projectId: string;
+    workspaceId: string;
+    ticket: JsonObject | null;
+    fromStatus: string | null;
+    toStatus: string;
+    statusChangeId?: string;
+    sessionId: string | null;
+    originalSessionId: string | null;
+    worktreePath: string | null;
+    workspace: JsonObject;
+}
+export interface SessionLifecyclePayload {
+    projectId: string;
+    sessionId: string;
+    sessionStatus?: string;
+    originalSessionId?: string;
+    workspace?: JsonObject;
+    workspaceId?: string;
+    worktreePath?: string;
+    branch?: string;
+    ticket?: JsonObject;
+    attemptStatus?: string;
+}
+export interface WorktreeRemovedPayload {
+    projectId: string;
+    repoPath?: string;
+    worktreePath: string;
+    workspace?: JsonObject;
+    workspaceId?: string;
+    ticket?: JsonObject | string;
+}
+export interface CommitPayload {
+    projectId: string;
+    repoPath?: string;
+    worktreePath?: string;
+    branch?: string;
+    commitSha?: string;
+    workspace?: JsonObject;
+    ticket?: JsonObject | string;
+}
+export interface RebasePayload {
+    projectId: string;
+    repoPath?: string;
+    worktreePath?: string;
+    branch?: string;
+    workspace?: JsonObject;
+    ticket?: JsonObject | string;
+}
+export interface MergePayload extends CommitPayload {
+}
+export interface ConflictPayload {
+    projectId: string;
+    operation: "rebase" | "merge";
+    repoPath?: string;
+    worktreePath?: string;
+    branch?: string;
+    workspace?: JsonObject;
+    ticket?: JsonObject | string;
+}
 export declare const projectSlots: {
     sidebarNav: import("./types").SlotRef<object, "navigation">;
     sidebar: import("./types").SlotRef<object, "view">;
@@ -25,15 +121,23 @@ export declare const projectEvents: {
     }>;
 };
 export declare const sessionEvents: {
-    started: import("./types").EventRef<{
-        sessionId: string;
+    started: import("./types").EventRef<SessionLifecyclePayload & {
         anchors?: ResourceAnchor[];
     }>;
-    completed: import("./types").EventRef<{
-        sessionId: string;
+    resumed: import("./types").EventRef<SessionLifecyclePayload>;
+    awaitingInput: import("./types").EventRef<SessionLifecyclePayload>;
+    succeeded: import("./types").EventRef<SessionLifecyclePayload>;
+    failed: import("./types").EventRef<SessionLifecyclePayload>;
+    completed: import("./types").EventRef<SessionLifecyclePayload & {
         anchors?: ResourceAnchor[];
     }>;
 };
+export declare const ticketEvents: {
+    created: import("./types").EventRef<TicketLifecyclePayload>;
+    statusChanged: import("./types").EventRef<TicketStatusChangePayload>;
+    archived: import("./types").EventRef<TicketArchivedEventPayload>;
+    deleted: import("./types").EventRef<TicketLifecyclePayload>;
+};
 export declare const workspaceEvents: {
     created: import("./types").EventRef<{
         workspace: JsonObject;
@@ -45,3 +149,19 @@ export declare const workspaceEvents: {
         workspace: JsonObject;
     }>;
 };
+export declare const worktreeEvents: {
+    created: import("./types").EventRef<WorktreeCreatedEventPayload>;
+    removed: import("./types").EventRef<WorktreeRemovedPayload>;
+};
+export declare const gitEvents: {
+    committed: import("./types").EventRef<CommitPayload>;
+    rebased: import("./types").EventRef<RebasePayload>;
+    merged: import("./types").EventRef<MergePayload>;
+    conflicted: import("./types").EventRef<ConflictPayload>;
+};
+export declare const attemptStatusEvents: {
+    changed: import("./types").EventRef<AttemptStatusChangePayload>;
+};
+export declare const workspaceCommands: {
+    setAttemptStatus: import("./types").CommandRef<SetAttemptStatusInput, SetAttemptStatusResult>;
+};

package/dist/extensions/types/context.d.ts

@@ -82,11 +82,36 @@ export interface ExtensionSessionsApi {
         vars?: JsonObject;
     }): Promise<void>;
 }
+export interface SetAttemptStatusInput {
+    workspaceId: string;
+    status: string;
+    sessionId?: string;
+}
+export interface SetAttemptStatusResult {
+    id: string;
+    attempt_status_id: string | null;
+    from_status: string | null;
+    to_status: string;
+    status_change_id: string;
+}
 export interface ExtensionWorkspacesApi {
     get(id: string): Promise<unknown>;
     create(input: JsonObject): Promise<unknown>;
     archive(id: string): Promise<void>;
     delete(id: string): Promise<void>;
+    setAttemptStatus(input: SetAttemptStatusInput): Promise<SetAttemptStatusResult>;
+}
+export interface BootstrapWorktreeInput {
+    repoPath: string;
+    worktreePath: string;
+    ticketId?: string;
+}
+export interface RemoveWorktreesForTicketInput {
+    ticketId?: string;
+}
+export interface ExtensionWorktreesApi {
+    bootstrap(input: BootstrapWorktreeInput): Promise<void>;
+    removeAllForTicket(input: RemoveWorktreesForTicketInput): Promise<number>;
 }
 export interface ExtensionReposApi {
     list(): Promise<RepoContext[]>;
@@ -117,13 +142,15 @@ export interface ProcessRunResult {
     stdout: string;
     stderr: string;
 }
+export interface ProcessRunInput {
+    command: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
 export interface ExtensionProcessApi {
-    run(input: {
-        command: string[];
-        cwd?: string;
-        env?: Record<string, string>;
-        timeoutMs?: number;
-    }): Promise<ProcessRunResult>;
+    run(input: ProcessRunInput): Promise<ProcessRunResult>;
+    runOrThrow(input: ProcessRunInput): Promise<ProcessRunResult>;
     spawnDetached(input: {
         command: string[];
         cwd?: string;
@@ -160,6 +187,7 @@ export interface ExtensionContextBase {
     files: ExtensionFilesApi;
     sessions: ExtensionSessionsApi;
     workspaces: ExtensionWorkspacesApi;
+    worktrees: ExtensionWorktreesApi;
     repos: ExtensionReposApi;
     commands: CommandHelpersApi;
     events: ExtensionEventsApi;

package/dist/extensions/types/extension.d.ts

@@ -164,5 +164,5 @@ export interface ExtensionLifecycle {
 export interface ExtensionDefinition extends UiContributions, BehaviourContributions, AssetContributions, ProviderContributions, ExtensionLifecycle {
     settings?: ParamObjectSchema;
 }
-export type ExtensionSourceKind = "local" | "package" | "builtin";
+export type ExtensionSourceKind = "local" | "package";
 export {};

package/dist/plugins/helpers/followup-session.d.ts

@@ -19,5 +19,11 @@ export declare const followupSession: (ctx: PluginHelperContext, input: Followup
     cwd: string | null;
     created_at: string;
     updated_at: string;
+    follow_up: {
+        status: "dispatched";
+    } | {
+        status: "queued";
+        queue_position: number;
+    };
 }>;
 export {};

package/dist/resources/index.d.ts

@@ -1,8 +1,11 @@
 export type { Repo } from "pstdio-api-contracts";
 export type { AgentAvailabilityType, AgentConfig, AgentInfo, AgentModel } from "./agent";
 export type { FileRecord } from "./file";
+export type { KnownAgent, KnownAgentId } from "./known-agents";
+export { findAgent, isKnownAgentId, KNOWN_AGENT_IDS, KNOWN_AGENTS } from "./known-agents";
 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 { AttemptStatus, Status } from "./status";
 export type { Tag, TagOption } from "./tag";

package/dist/resources/index.js

@@ -0,0 +1,26 @@
+// src/resources/known-agents.ts
+var KNOWN_AGENTS = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    binary: "claude",
+    skillsDir: ".claude/skills",
+    globalSkillsDir: ".claude/skills"
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    binary: "opencode",
+    skillsDir: ".opencode/skills",
+    globalSkillsDir: ".opencode/skills"
+  }
+];
+var KNOWN_AGENT_IDS = KNOWN_AGENTS.map((agent) => agent.id);
+var findAgent = (id) => KNOWN_AGENTS.find((agent) => agent.id === id) ?? null;
+var isKnownAgentId = (id) => KNOWN_AGENT_IDS.includes(id);
+export {
+  isKnownAgentId,
+  findAgent,
+  KNOWN_AGENT_IDS,
+  KNOWN_AGENTS
+};

package/dist/resources/known-agents.d.ts

@@ -0,0 +1,12 @@
+export type KnownAgentId = "claude-code" | "opencode" | "fake";
+export type KnownAgent = {
+    id: KnownAgentId;
+    name: string;
+    binary: string;
+    skillsDir: string;
+    globalSkillsDir: string;
+};
+export declare const KNOWN_AGENTS: KnownAgent[];
+export declare const KNOWN_AGENT_IDS: KnownAgentId[];
+export declare const findAgent: (id: string) => KnownAgent | null;
+export declare const isKnownAgentId: (id: string) => id is KnownAgentId;

package/dist/resources/settings.d.ts

@@ -0,0 +1 @@
+export type { Settings } from "pstdio-api-contracts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pstdio/sdk",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/pufflyai/prompt-studio"