Skip to content

Workspaces

60 methods on the Workspaces resource.

60 methods · 14 available to app tokens36 pages in SDK Reference

import { Compozy } from "@compozy/client";

60 of 60

answerTerminalInputRequest

Answer one terminal input request

compozy.workspaces.answerTerminalInputRequest({ path, query, body }) → Promise<TerminalInputAnswerResponse>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
request_idstringpathrequired
Terminal input request id
profilestringquery
Act as this profile by name

Request bodyTerminalAnswerInputRequest

POST /api/workspaces/{workspace_id}/terminals/{id}/input-requests/{request_id}/answerapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.answerTerminalInputRequest({ path: { "workspace_id": "workspace_id", "id": "id", "request_id": "request_id" }, body: { /* request fields */ } });

archiveWorkspace

archive a workspace without removing its data

compozy.workspaces.archiveWorkspace({ path }) → Promise<WorkspaceResponse>

Options

idstringpathrequired
Workspace name or id

POST /api/workspaces/{id}/archiveapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.archiveWorkspace({ path: { "id": "id" } });

controlTerminalRecording

Start or stop terminal recording

compozy.workspaces.controlTerminalRecording({ path, query, body }) → Promise<TerminalRecordingResponse>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
profilestringquery
Act as this profile by name

Request bodyTerminalRecordingRequest

POST /api/workspaces/{workspace_id}/terminals/{id}/recordingapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.controlTerminalRecording({ path: { "workspace_id": "workspace_id", "id": "id" }, body: { /* request fields */ } });

createTerminal

Create an interactive terminal

compozy.workspaces.createTerminal({ path, query, headers, body }) → Promise<TerminalResponse>

Options

workspace_idstringpathrequired
Workspace id
X-Compozy-Client-Tokenstringheader
Registered browser client attachment token
X-Compozy-Client-Workspacestringheader
Browser client registration partition (project id, global, or user); defaults to the terminal workspace
profilestringquery
Act as this profile by name

Request bodyTerminalCreateRequest

POST /api/workspaces/{workspace_id}/terminalsapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.createTerminal({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });

createWorkspace

Register a workspace

compozy.workspaces.createWorkspace({ body }) → Promise<WorkspaceResponse>

Request bodyCreateWorkspaceRequest

POST /api/workspacesapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.createWorkspace({ body: { /* request fields */ } });

createWorkspaceFolder

Create a root workspace folder

compozy.workspaces.createWorkspaceFolder({ query, body }) → Promise<WorkspaceFolderResponse>

Options

profilestringquery
Act as this profile by name

Request bodyCreateWorkspaceFolderRequest

POST /api/workspace-foldersapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.createWorkspaceFolder({ body: { /* request fields */ } });

deleteTerminal

Terminate one terminal

compozy.workspaces.deleteTerminal({ path, query, body }) → Promise<TerminalExitResponse>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
profilestringquery
Act as this profile by name

Request bodyTerminalCloseRequest

DELETE /api/workspaces/{workspace_id}/terminals/{id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.deleteTerminal({ path: { "workspace_id": "workspace_id", "id": "id" }, body: { /* request fields */ } });

deleteWindowManagerLayoutProfile

Delete one workspace-visible layout profile

compozy.workspaces.deleteWindowManagerLayoutProfile({ path, query, body }) → Promise<void>

Options

workspace_idstringpathrequired
Workspace id
profile_idstringpathrequired
Layout profile id
profilestringquery
Act as this profile by name

Request bodyDeleteResourceRequest

DELETE /api/workspaces/{workspace_id}/window-manager/layout-profiles/{profile_id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.deleteWindowManagerLayoutProfile({ path: { "workspace_id": "workspace_id", "profile_id": "profile_id" }, body: { /* request fields */ } });

deleteWorkspace

Delete a registered workspace

compozy.workspaces.deleteWorkspace({ path }) → Promise<void>

Options

idstringpathrequired
Workspace id

DELETE /api/workspaces/{id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.deleteWorkspace({ path: { "id": "id" } });

deleteWorkspaceFolder

Delete a workspace folder; its workspaces return to the root

compozy.workspaces.deleteWorkspaceFolder({ path, query }) → Promise<WorkspaceLayoutResponse>

Options

folder_idstringpathrequired
Workspace folder id
profilestringquery
Act as this profile by name

DELETE /api/workspace-folders/{folder_id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.deleteWorkspaceFolder({ path: { "folder_id": "folder_id" } });
Show all 60 methods

downloadTerminalArtifact

Download one terminal spill artifact

compozy.workspaces.downloadTerminalArtifact({ path, query }) → Promise<Blob | File>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/terminals/artifacts/{id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.downloadTerminalArtifact({ path: { "workspace_id": "workspace_id", "id": "id" } });

downloadTerminalRecording

Download one terminal recording

compozy.workspaces.downloadTerminalRecording({ path, query }) → Promise<Blob | File>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/terminals/recordings/{id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.downloadTerminalRecording({ path: { "workspace_id": "workspace_id", "id": "id" } });

execTerminal

Execute one supervised workspace command

compozy.workspaces.execTerminal({ path, query, body }) → Promise<ExecTerminalResponse>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

Request bodyTerminalExecRequest

POST /api/workspaces/{workspace_id}/terminals/execapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.execTerminal({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });

executeWindowManagerCommand

Execute one semantic window-manager command

compozy.workspaces.executeWindowManagerCommand({ path, query, body }) → Promise<ContractWindowManagerResult>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

Request bodyContractWindowManagerCommandRequest

POST /api/workspaces/{workspace_id}/window-manager/commandsapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.executeWindowManagerCommand({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });

exportWindowManagerLayout

Export one declarative window layout

compozy.workspaces.exportWindowManagerLayout({ path, query }) → Promise<ContractWindowManagerLayoutDocument>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

GET /api/workspaces/{workspace_id}/window-manager/layoutapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.exportWindowManagerLayout({ path: { "workspace_id": "workspace_id" } });

findFiles

Find project files

compozy.workspaces.findFiles({ path, query }) → Promise<FileFindResponse>

Options

workspace_idstringpathrequired
Workspace id
worktree_idstringquery
Optional worktree id
qstringqueryrequired
Search query
limitintegerquery
Result limit; defaults and clamps to 50
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/files/findapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.findFiles({ path: { "workspace_id": "workspace_id" }, query: { "q": "q" } });

findSessionFiles

Find project files

compozy.workspaces.findSessionFiles({ path, query }) → Promise<FileFindResponse>

Options

workspace_idstringpathrequired
Workspace id
session_idstringpathrequired
Session id
qstringqueryrequired
Search query
limitintegerquery
Result limit; defaults and clamps to 50
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/sessions/{session_id}/files/findapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.findSessionFiles({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "q": "q" } });

getSessionChangeContents

Read session changes

compozy.workspaces.getSessionChangeContents({ path, query }) → Promise<SessionChangeContentsResponse>

Options

workspace_idstringpathrequired
Workspace id
session_idstringpathrequired
Session id
scope"branch" | "uncommitted"query
Changes scope
basestringquery
Optional base ref
revisionstringqueryrequired
Summary revision fence
pathstringqueryrequired
Root-relative path
old_pathstringquery
Aligned old path for renames
revealbooleanquery
Reveal sensitive contents; forbidden to app tokens
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/sessions/{session_id}/changes/contentsapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.getSessionChangeContents({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "revision": "revision", "path": "path" } });

getSessionChangePatches

Read session changes

compozy.workspaces.getSessionChangePatches({ path, query }) → Promise<SessionChangePatchesResponse>

Options

workspace_idstringpathrequired
Workspace id
session_idstringpathrequired
Session id
scope"branch" | "uncommitted"query
Changes scope
basestringquery
Optional base ref
revisionstringqueryrequired
Summary revision fence
pathstring[]queryrequired
Root-relative path
old_pathstring[]query
Aligned old path for renames
revealbooleanquery
Reveal sensitive contents; forbidden to app tokens
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/sessions/{session_id}/changes/patchesapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.getSessionChangePatches({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "revision": "revision", "path": ["path"] } });

getSessionChanges

Read session changes

compozy.workspaces.getSessionChanges({ path, query }) → Promise<SessionChangesResponse>

Options

workspace_idstringpathrequired
Workspace id
session_idstringpathrequired
Session id
scope"branch" | "uncommitted"query
Changes scope
basestringquery
Optional base ref
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/sessions/{session_id}/changesapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.getSessionChanges({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });

getTerminal

Read one terminal

compozy.workspaces.getTerminal({ path, query }) → Promise<TerminalResponse>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/terminals/{id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.getTerminal({ path: { "workspace_id": "workspace_id", "id": "id" } });

getWindowManagerSnapshot

Read one workspace window-manager snapshot

compozy.workspaces.getWindowManagerSnapshot({ path, query }) → Promise<ContractWindowManagerSnapshot>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

GET /api/workspaces/{workspace_id}/window-managerapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.getWindowManagerSnapshot({ path: { "workspace_id": "workspace_id" } });

getWorkspace

Get one resolved workspace with related data

compozy.workspaces.getWorkspace({ path }) → Promise<WorkspaceDetailPayload>

Options

idstringpathrequired
Workspace id or path

GET /api/workspaces/{id}app tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.getWorkspace({ path: { "id": "id" } });

getWorkspaceLayout

Read the profile's workspace folders and manual workspace order

compozy.workspaces.getWorkspaceLayout({ query }) → Promise<WorkspaceLayoutResponse>

Options

profilestringquery
Act as this profile by name

GET /api/workspace-foldersapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.getWorkspaceLayout();

listFileEntries

List project file entries

compozy.workspaces.listFileEntries({ path, query }) → Promise<FileEntriesResponse>

Options

workspace_idstringpathrequired
Workspace id
worktree_idstringquery
Optional worktree id
pathstringquery
Root-relative path
show_ignoredbooleanquery
Include ignored entries
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/files/entriesapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.listFileEntries({ path: { "workspace_id": "workspace_id" } });

listSessionChangeBases

Read session changes

compozy.workspaces.listSessionChangeBases({ path, query }) → Promise<SessionChangeBasesResponse>

Options

workspace_idstringpathrequired
Workspace id
session_idstringpathrequired
Session id
qstringquery
Substring ref filter
limitintegerquery
Default 200, maximum 500
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/sessions/{session_id}/changes/basesapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.listSessionChangeBases({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });

listSessionFileEntries

List project file entries

compozy.workspaces.listSessionFileEntries({ path, query }) → Promise<FileEntriesResponse>

Options

workspace_idstringpathrequired
Workspace id
session_idstringpathrequired
Session id
pathstringquery
Root-relative path
show_ignoredbooleanquery
Include ignored entries
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/sessions/{session_id}/files/entriesapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.listSessionFileEntries({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });

listTerminalInputRequests

List pending terminal input requests

compozy.workspaces.listTerminalInputRequests({ path, query }) → Promise<TerminalInputRequestsResponse>

Options

workspace_idstringpathrequired
Workspace id
terminal_idstringquery
Filter by terminal id
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/terminals/input-requestsapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.listTerminalInputRequests({ path: { "workspace_id": "workspace_id" } });

listTerminals

List workspace terminals

compozy.workspaces.listTerminals({ path, query }) → Promise<TerminalListResponse>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/terminalsapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.listTerminals({ path: { "workspace_id": "workspace_id" } });

listTerminalsAggregate

List workspace terminals

compozy.workspaces.listTerminalsAggregate({ query }) → Promise<TerminalListResponse>

Options

all_workspacesbooleanquery
Read all projects and User rows
workspace_idsstring[]query
Repeatable project IDs or @user; requires all_workspaces=true
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/terminalsapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.listTerminalsAggregate();

listWindowManagerClients

List connected window-manager clients

compozy.workspaces.listWindowManagerClients({ path, query }) → Promise<ContractWindowManagerClientsResponse>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

GET /api/workspaces/{workspace_id}/window-manager/clientsapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.listWindowManagerClients({ path: { "workspace_id": "workspace_id" } });

listWindowManagerLayoutProfiles

List layout profiles visible to one workspace

compozy.workspaces.listWindowManagerLayoutProfiles({ path, query }) → Promise<ResourcesResponse>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

GET /api/workspaces/{workspace_id}/window-manager/layout-profilesapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.listWindowManagerLayoutProfiles({ path: { "workspace_id": "workspace_id" } });

listWorkspaces

List active or archived workspaces

compozy.workspaces.listWorkspaces({ query }) → Promise<WorkspacesResponse>

Options

archivedbooleanquery
List archived projects instead of active projects

GET /api/workspacesapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.listWorkspaces();

mintTerminalAttachTicket

Mint a single-use terminal attach ticket

compozy.workspaces.mintTerminalAttachTicket({ path, query, headers, body }) → Promise<TerminalAttachTicketResponse>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
X-Compozy-Client-Tokenstringheader
Registered browser client attachment token
X-Compozy-Client-Workspacestringheader
Browser client registration partition (project id, global, or user); defaults to the terminal workspace
profilestringquery
Act as this profile by name

Request bodyTerminalAttachTicketRequest

POST /api/workspaces/{workspace_id}/terminals/{id}/attach-ticketapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.mintTerminalAttachTicket({ path: { "workspace_id": "workspace_id", "id": "id" }, body: { /* request fields */ } });

moveWorkspace

Move a workspace into a folder or back to the root

compozy.workspaces.moveWorkspace({ query, body }) → Promise<WorkspaceLayoutResponse>

Options

profilestringquery
Act as this profile by name

Request bodyMoveWorkspaceRequest

POST /api/workspace-order/moveapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.moveWorkspace({ body: { /* request fields */ } });

previewWindowManagerCommand

Preview one semantic window-manager command

compozy.workspaces.previewWindowManagerCommand({ path, query, body }) → Promise<ContractWindowManagerPreview>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

Request bodyContractWindowManagerCommandRequest

POST /api/workspaces/{workspace_id}/window-manager/previewapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.previewWindowManagerCommand({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });

putWindowManagerLayoutProfile

Create or replace one workspace-visible layout profile

compozy.workspaces.putWindowManagerLayoutProfile({ path, query, body }) → Promise<PutWindowManagerLayoutProfileResponse>

Options

workspace_idstringpathrequired
Workspace id
profile_idstringpathrequired
Layout profile id
profilestringquery
Act as this profile by name

Request bodyPutResourceRequest

PUT /api/workspaces/{workspace_id}/window-manager/layout-profiles/{profile_id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.putWindowManagerLayoutProfile({ path: { "workspace_id": "workspace_id", "profile_id": "profile_id" }, body: { /* request fields */ } });

queryTerminalJournal

Query terminal command history

compozy.workspaces.queryTerminalJournal({ path, query }) → Promise<TerminalJournalResponse>

Options

workspace_idstringpathrequired
Workspace id
actor"human" | "agent"query
Filter by actor kind
sincestringquery
Filter by relative duration
failedbooleanquery
Only failed commands
terminal_idstringquery
Filter by terminal id
limitintegerquery
Page size
cursorstringquery
Opaque page cursor
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/terminals/journalapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.queryTerminalJournal({ path: { "workspace_id": "workspace_id" } });

readFileContent

Read project file content

compozy.workspaces.readFileContent({ path, query }) → Promise<FileContentResponse>

Options

workspace_idstringpathrequired
Workspace id
worktree_idstringquery
Optional worktree id
pathstringqueryrequired
Root-relative path
revealbooleanquery
Reveal sensitive content; forbidden to app tokens
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/files/contentapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.readFileContent({ path: { "workspace_id": "workspace_id" }, query: { "path": "path" } });

readSessionFileContent

Read project file content

compozy.workspaces.readSessionFileContent({ path, query }) → Promise<FileContentResponse>

Options

workspace_idstringpathrequired
Workspace id
session_idstringpathrequired
Session id
pathstringqueryrequired
Root-relative path
revealbooleanquery
Reveal sensitive content; forbidden to app tokens
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/sessions/{session_id}/files/contentapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.readSessionFileContent({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "path": "path" } });

readTerminal

Read bounded untrusted terminal output

compozy.workspaces.readTerminal({ path, query }) → Promise<TerminalReadResponse>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
view"screen" | "tail" | "lines"query
Terminal read view
max_bytesintegerquery
Maximum returned bytes
grepstringquery
Optional regular expression
since_seqstringquery
Decimal uint64 after the last consumed sequence
fromintegerquery
First scrollback line
tointegerquery
Last scrollback line
profilestringquery
Act as this profile by name

GET /api/workspaces/{workspace_id}/terminals/{id}/readapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.readTerminal({ path: { "workspace_id": "workspace_id", "id": "id" } });

registerWindowManagerClient

Register a window-manager client view

compozy.workspaces.registerWindowManagerClient({ path, query, body }) → Promise<ContractWindowManagerClientView>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

Request bodyContractWindowManagerClientRegistration

POST /api/workspaces/{workspace_id}/window-manager/clientsapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.registerWindowManagerClient({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });

rejectTerminalInputRequest

Reject one terminal input request

compozy.workspaces.rejectTerminalInputRequest({ path, query, body }) → Promise<TerminalInputRejectResponse>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
request_idstringpathrequired
Terminal input request id
profilestringquery
Act as this profile by name

Request bodyTerminalRejectInputRequest

POST /api/workspaces/{workspace_id}/terminals/{id}/input-requests/{request_id}/rejectapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.rejectTerminalInputRequest({ path: { "workspace_id": "workspace_id", "id": "id", "request_id": "request_id" }, body: { /* request fields */ } });

renameWorkspaceFolder

Rename a workspace folder

compozy.workspaces.renameWorkspaceFolder({ path, query, body }) → Promise<WorkspaceFolderResponse>

Options

folder_idstringpathrequired
Workspace folder id
profilestringquery
Act as this profile by name

Request bodyRenameWorkspaceFolderRequest

PATCH /api/workspace-folders/{folder_id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.renameWorkspaceFolder({ path: { "folder_id": "folder_id" }, body: { /* request fields */ } });

reorderWorkspaceFolders

Set the complete workspace folder order

compozy.workspaces.reorderWorkspaceFolders({ query, body }) → Promise<WorkspaceLayoutResponse>

Options

profilestringquery
Act as this profile by name

Request bodyReorderWorkspaceFoldersRequest

PUT /api/workspace-order/foldersapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.reorderWorkspaceFolders({ body: { /* request fields */ } });

reorderWorkspaces

Set the manual workspace order in a folder or the root

compozy.workspaces.reorderWorkspaces({ query, body }) → Promise<WorkspaceLayoutResponse>

Options

profilestringquery
Act as this profile by name

Request bodyReorderWorkspacesRequest

PUT /api/workspace-order/workspacesapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.reorderWorkspaces({ body: { /* request fields */ } });

replaceWindowManagerLayout

Replace one declarative window layout

compozy.workspaces.replaceWindowManagerLayout({ path, query, body }) → Promise<ContractWindowManagerResult>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

Request bodyContractWindowManagerLayoutReplaceRequest

PUT /api/workspaces/{workspace_id}/window-manager/layoutapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.replaceWindowManagerLayout({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });

resolveWorkspace

Resolve or register a workspace from a path

compozy.workspaces.resolveWorkspace({ body }) → Promise<WorkspaceResponse>

Request bodyResolveWorkspaceRequest

POST /api/workspaces/resolveapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.resolveWorkspace({ body: { /* request fields */ } });

searchFileContents

Search project file contents

compozy.workspaces.searchFileContents({ path, query }) → Promise<FileSearchResponse>

Options

workspace_idstringpathrequired
Workspace id
worktree_idstringquery
Optional worktree id
qstringqueryrequired
Search query
regexbooleanquery
Use POSIX ERE
case_sensitivebooleanquery
Match case
whole_wordbooleanquery
Match whole words
includestring[]query
Root-relative globs; repeat at most ten times
excludestring[]query
Root-relative globs; repeat at most ten times
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/files/searchapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.searchFileContents({ path: { "workspace_id": "workspace_id" }, query: { "q": "q" } });

searchSessionFileContents

Search project file contents

compozy.workspaces.searchSessionFileContents({ path, query }) → Promise<FileSearchResponse>

Options

workspace_idstringpathrequired
Workspace id
session_idstringpathrequired
Session id
qstringqueryrequired
Search query
regexbooleanquery
Use POSIX ERE
case_sensitivebooleanquery
Match case
whole_wordbooleanquery
Match whole words
includestring[]query
Root-relative globs; repeat at most ten times
excludestring[]query
Root-relative globs; repeat at most ten times
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/sessions/{session_id}/files/searchapp tokens allowed

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.searchSessionFileContents({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "q": "q" } });

signalTerminal

Signal one running terminal

compozy.workspaces.signalTerminal({ path, query, body }) → Promise<TerminalDeliveredResponse>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
profilestringquery
Act as this profile by name

Request bodyTerminalSignalRequest

POST /api/workspaces/{workspace_id}/terminals/{id}/signalapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.signalTerminal({ path: { "workspace_id": "workspace_id", "id": "id" }, body: { /* request fields */ } });

streamTerminal

Upgrade to one live terminal byte stream

No client method: this route upgrades to a WebSocket.

Route parameters

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
ticketstringqueryrequired
Single-use attach ticket
mode"read" | "write"query
Attach mode
colsintegerquery
Proposed terminal columns
rowsintegerquery
Proposed terminal rows
after_seqstringquery
Decimal uint64 after the last parsed terminal sequence
flow"ack" | "drop"query
Flow-control mode

GET /api/workspaces/{workspace_id}/terminals/{id}/streamapp tokens denied

streamTerminalCatalog

Stream the workspace terminal catalog

compozy.events("streamTerminalCatalog", { path, query }) → AsyncIterable<StreamEvent<SseFrame<"streamTerminalCatalog">>>

Options

workspace_idstringpathrequired
Workspace id
last_event_idstringquery
Resume cursor when Last-Event-ID cannot be set; the header takes precedence
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/workspaces/{workspace_id}/terminals/streamapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();for await (const frame of compozy.events("streamTerminalCatalog", { path: { "workspace_id": "workspace_id" } })) {  console.log(frame);}

streamTerminalsAggregate

Stream the workspace terminal catalog

compozy.events("streamTerminalsAggregate", { query }) → AsyncIterable<StreamEvent<SseFrame<"streamTerminalsAggregate">>>

Options

all_workspacesbooleanquery
Read all projects and User rows
workspace_idsstring[]query
Repeatable project IDs or @user; requires all_workspaces=true
last_event_idstringquery
Resume cursor when Last-Event-ID cannot be set; the header takes precedence
profilestringquery
Read one profile's rows by name
all_profilesbooleanquery
Read the owner-labeled all-profiles aggregate

GET /api/terminals/catalog-streamapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();for await (const frame of compozy.events("streamTerminalsAggregate", {})) {  console.log(frame);}

streamWindowManager

Stream a topology and optional client presentation fence

No client method: this route upgrades to a WebSocket.

Route parameters

workspace_idstringpathrequired
Workspace id
after_revisionintegerquery
Last applied window-manager revision
client_idstringquery
Optional connected client bound to presentation updates
profilestringquery
Act as this profile by name

GET /api/workspaces/{workspace_id}/window-manager/streamapp tokens denied

unarchiveWorkspace

unarchive a workspace without removing its data

compozy.workspaces.unarchiveWorkspace({ path }) → Promise<WorkspaceResponse>

Options

idstringpathrequired
Workspace name or id

POST /api/workspaces/{id}/unarchiveapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.unarchiveWorkspace({ path: { "id": "id" } });

unregisterWindowManagerClient

Unregister a window-manager client view

compozy.workspaces.unregisterWindowManagerClient({ path, query }) → Promise<void>

Options

workspace_idstringpathrequired
Workspace id
client_idstringpathrequired
Connected window-manager client id
profilestringquery
Act as this profile by name

DELETE /api/workspaces/{workspace_id}/window-manager/clients/{client_id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.unregisterWindowManagerClient({ path: { "workspace_id": "workspace_id", "client_id": "client_id" } });

updateWorkspace

Update a registered workspace

compozy.workspaces.updateWorkspace({ path, body }) → Promise<WorkspaceResponse>

Options

idstringpathrequired
Workspace id

Request bodyUpdateWorkspaceRequest

PATCH /api/workspaces/{id}app tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.updateWorkspace({ path: { "id": "id" }, body: { /* request fields */ } });

validateWindowManagerLayout

Validate one declarative window layout

compozy.workspaces.validateWindowManagerLayout({ path, query, body }) → Promise<ContractWindowManagerLayoutValidationResponse>

Options

workspace_idstringpathrequired
Workspace id
profilestringquery
Act as this profile by name

Request bodyContractWindowManagerLayoutValidationRequest

POST /api/workspaces/{workspace_id}/window-manager/layout/validateapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.validateWindowManagerLayout({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });

waitTerminal

Wait for one terminal condition

compozy.workspaces.waitTerminal({ path, query, body }) → Promise<TerminalWaitResponse>

Options

workspace_idstringpathrequired
Workspace id
idstringpathrequired
Terminal or retained artifact id
profilestringquery
Act as this profile by name

Request bodyTerminalWaitRequest

POST /api/workspaces/{workspace_id}/terminals/{id}/waitapp tokens denied

example.ts
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.workspaces.waitTerminal({ path: { "workspace_id": "workspace_id", "id": "id" }, body: { /* request fields */ } });