feat: show repository scripts in dockview "+" menu (#703)

This commit is contained in:
Carlos Florêncio
2026-04-25 18:40:31 +01:00
committed by GitHub
parent a79fd85074
commit 7a2160f1f9
12 changed files with 556 additions and 70 deletions
@@ -224,82 +224,94 @@ func (h *ShellHandlers) wsUserShellList(ctx context.Context, msg *ws.Message) (*
})
}
// UserShellCreateRequest for user_shell.create action
// UserShellCreateRequest for user_shell.create action.
// Exactly one of (ScriptID) or (Command) may be set; if both are empty the
// handler creates a plain shell. When Command is set, Label is used as the
// terminal label (defaults to "Script" when omitted).
type UserShellCreateRequest struct {
SessionID string `json:"session_id"`
ScriptID string `json:"script_id,omitempty"` // Optional: create a script terminal instead of plain shell
ScriptID string `json:"script_id,omitempty"`
Command string `json:"command,omitempty"`
Label string `json:"label,omitempty"`
}
// wsUserShellCreate creates a new user shell terminal and returns the assigned ID and label
// wsUserShellCreate creates a new user shell terminal and returns the assigned ID and label.
func (h *ShellHandlers) wsUserShellCreate(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req UserShellCreateRequest
if err := msg.ParsePayload(&req); err != nil {
return nil, fmt.Errorf("invalid payload: %w", err)
}
if req.SessionID == "" {
return nil, fmt.Errorf("session_id is required")
}
// Get the interactive runner
interactiveRunner := h.lifecycleMgr.GetInteractiveRunner()
if interactiveRunner == nil {
return nil, fmt.Errorf("interactive runner not available")
}
var terminalID, label, initialCommand string
var closable bool
if req.ScriptID != "" {
// Creating a script terminal - look up the script
if h.scriptService == nil {
return nil, fmt.Errorf("script service not available")
}
script, err := h.scriptService.GetRepositoryScript(ctx, req.ScriptID)
if err != nil {
h.logger.Error("failed to get repository script",
zap.String("script_id", req.ScriptID),
zap.Error(err))
return nil, fmt.Errorf("invalid script ID: %w", err)
}
terminalID = "script-" + uuid.New().String()
label = script.Name
initialCommand = script.Command
closable = true // Script terminals are always closable
// Register the script terminal with the interactive runner
interactiveRunner.RegisterScriptShell(req.SessionID, terminalID, label, initialCommand)
label, command, err := h.resolveShellScript(ctx, &req)
if err != nil {
return nil, err
}
if command != "" {
terminalID := "script-" + uuid.New().String()
interactiveRunner.RegisterScriptShell(req.SessionID, terminalID, label, command)
h.logger.Info("created script terminal",
zap.String("session_id", req.SessionID),
zap.String("terminal_id", terminalID),
zap.String("label", label),
zap.String("script_id", req.ScriptID),
zap.String("initial_command", initialCommand))
} else {
// Creating a plain shell terminal
result := interactiveRunner.CreateUserShell(req.SessionID)
terminalID = result.TerminalID
label = result.Label
closable = result.Closable
h.logger.Info("created user shell",
zap.String("session_id", req.SessionID),
zap.String("terminal_id", terminalID),
zap.String("label", label),
zap.Bool("closable", closable))
zap.String("initial_command", command))
return ws.NewResponse(msg.ID, msg.Action, map[string]any{
"terminal_id": terminalID,
"label": label,
"closable": true,
"initial_command": command,
})
}
result := interactiveRunner.CreateUserShell(req.SessionID)
h.logger.Info("created user shell",
zap.String("session_id", req.SessionID),
zap.String("terminal_id", result.TerminalID),
zap.String("label", result.Label),
zap.Bool("closable", result.Closable))
return ws.NewResponse(msg.ID, msg.Action, map[string]any{
"terminal_id": terminalID,
"label": label,
"closable": closable,
"initial_command": initialCommand,
"terminal_id": result.TerminalID,
"label": result.Label,
"closable": result.Closable,
"initial_command": "",
})
}
// resolveShellScript returns the (label, command) pair for a script terminal,
// or ("", "") when the request is for a plain shell.
func (h *ShellHandlers) resolveShellScript(
ctx context.Context, req *UserShellCreateRequest,
) (string, string, error) {
if req.ScriptID != "" {
if h.scriptService == nil {
return "", "", fmt.Errorf("script service not available")
}
script, err := h.scriptService.GetRepositoryScript(ctx, req.ScriptID)
if err != nil {
h.logger.Error("failed to get repository script",
zap.String("script_id", req.ScriptID), zap.Error(err))
return "", "", fmt.Errorf("invalid script ID: %w", err)
}
return script.Name, script.Command, nil
}
if req.Command != "" {
label := req.Label
if label == "" {
label = "Script"
}
return label, req.Command, nil
}
return "", "", nil
}
// UserShellStopRequest for user_shell.stop action
type UserShellStopRequest struct {
SessionID string `json:"session_id"`
@@ -441,6 +441,65 @@ func TestWsUserShellCreate_ScriptID_NoScriptService(t *testing.T) {
}
}
func TestResolveShellScript(t *testing.T) {
log := newTestLogger()
h := NewShellHandlers(nil, nil, log)
ctx := context.Background()
t.Run("plain shell when no script_id and no command", func(t *testing.T) {
label, cmd, err := h.resolveShellScript(ctx, &UserShellCreateRequest{SessionID: "s1"})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if label != "" || cmd != "" {
t.Errorf("expected empty label/command, got label=%q command=%q", label, cmd)
}
})
t.Run("inline command with explicit label", func(t *testing.T) {
label, cmd, err := h.resolveShellScript(ctx, &UserShellCreateRequest{
SessionID: "s1",
Command: "echo hi",
Label: "Dev Server",
})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if label != "Dev Server" {
t.Errorf("label = %q, want %q", label, "Dev Server")
}
if cmd != "echo hi" {
t.Errorf("command = %q, want %q", cmd, "echo hi")
}
})
t.Run("inline command defaults label to Script", func(t *testing.T) {
label, cmd, err := h.resolveShellScript(ctx, &UserShellCreateRequest{
SessionID: "s1",
Command: "ls",
})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if label != "Script" {
t.Errorf("label = %q, want %q", label, "Script")
}
if cmd != "ls" {
t.Errorf("command = %q, want %q", cmd, "ls")
}
})
t.Run("script_id without script service errors", func(t *testing.T) {
_, _, err := h.resolveShellScript(ctx, &UserShellCreateRequest{
SessionID: "s1",
ScriptID: "abc",
})
if err == nil {
t.Fatal("expected error when script service is nil")
}
})
}
func TestWsUserShellStop_InvalidPayload(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, nil, log)
@@ -39,6 +39,7 @@ func (r *InteractiveRunner) readOutput(proc *interactiveProcess) {
firstRead = false
}
if n > 0 {
proc.firstOutputOnce.Do(func() { close(proc.firstOutputCh) })
recentOutput = r.processOutputData(proc, ptyInstance, buf[:n], recentOutput)
}
if err != nil {
@@ -55,6 +55,13 @@ type interactiveProcess struct {
stopSignal chan struct{}
waitDone chan struct{} // closed when wait() returns (cmd.Wait completed)
mu sync.Mutex
// firstOutputCh is closed by readOutput once any bytes arrive from the PTY —
// a reliable proxy for "shell has rendered its prompt and is ready for input".
// InitialCommand writes wait on this so heavy zsh/bash startup scripts don't
// race with stdin echo (which would otherwise duplicate the command in output).
firstOutputOnce sync.Once
firstOutputCh chan struct{}
}
// Start creates an interactive process entry and defers PTY creation until first resize.
@@ -116,6 +123,7 @@ func (r *InteractiveRunner) Start(ctx context.Context, req InteractiveStartReque
isUserShell: req.IsUserShell,
stopSignal: make(chan struct{}),
waitDone: make(chan struct{}),
firstOutputCh: make(chan struct{}),
// Store start parameters for deferred initialization
started: false,
startCmd: req.Command,
@@ -267,11 +275,21 @@ func (r *InteractiveRunner) startProcess(proc *interactiveProcess, cols, rows in
go r.readOutput(proc)
go r.wait(proc)
// If an initial command was provided, write it to the PTY after a short delay
// to allow the shell to initialize and display its prompt
// Wait for the shell to print its prompt before writing the initial command.
// readOutput closes firstOutputCh on the first PTY read; without that gate a
// heavy zsh/bash startup races the write and zsh ends up rendering the
// command twice — once from PTY echo, once when it repaints with the
// pending input. We still cap the wait so silent shells don't hang.
if req.InitialCommand != "" {
go func() {
time.Sleep(100 * time.Millisecond)
select {
case <-proc.firstOutputCh:
case <-time.After(2 * time.Second):
r.logger.Warn("initial command write timed out waiting for shell prompt",
zap.String("process_id", proc.info.ID))
}
// Brief settle so the prompt is fully painted before we type into it.
time.Sleep(50 * time.Millisecond)
proc.mu.Lock()
pty := proc.ptmx
proc.mu.Unlock()
@@ -104,6 +104,20 @@ func (r *InteractiveRunner) RegisterScriptShell(sessionID, terminalID, label, in
}
}
// LookupShellInitialCommand returns the InitialCommand stored for a pre-registered
// shell entry, or "" when no entry exists. Used by remote-shell handlers to recover
// the script command across the WS-handshake boundary, since the per-terminal WS URL
// only carries terminalId — not script_id or command.
func (r *InteractiveRunner) LookupShellInitialCommand(sessionID, terminalID string) string {
key := sessionID + ":" + terminalID
r.userShellsMu.RLock()
defer r.userShellsMu.RUnlock()
if entry, ok := r.userShells[key]; ok {
return entry.InitialCommand
}
return ""
}
// StartUserShell starts or returns an existing user shell for a terminal tab.
// Each terminal tab gets its own independent shell process.
// If opts.InitialCommand is provided, it will be written to stdin after the shell starts.
@@ -277,6 +277,15 @@ func (h *TerminalHandler) handleRemoteUserShellWS(c *gin.Context, sessionID, ter
c.JSON(http.StatusBadRequest, gin.H{"error": httpErr})
return
}
// The per-terminal WS URL only carries terminalId, so fall back to the
// command pre-registered by wsUserShellCreate when the URL didn't include
// scriptId or label-derived command. Without this, script terminals (custom
// scripts and dev_script) would open empty in containerized sessions.
if initialCommand == "" {
if runner := h.lifecycleMgr.GetInteractiveRunner(); runner != nil {
initialCommand = runner.LookupShellInitialCommand(sessionID, terminalID)
}
}
// Create a per-terminal shell on agentctl (idempotent if already exists)
if err := client.StartShellTerminal(c.Request.Context(), terminalID, 80, 24); err != nil {
@@ -41,6 +41,7 @@ import type { Task, ProcessInfo } from "@/lib/types/http";
import type { ProcessStatusEntry } from "@/lib/state/slices";
import { NewSessionDialog } from "./new-session-dialog";
import { NewTaskDropdown } from "./new-task-dropdown";
import { RepositoryScriptsMenuItems, useActiveSessionDevScript } from "./repository-scripts-menu";
import { SessionReopenMenuItems } from "./session-reopen-menu";
/** Map a ProcessInfo response to a ProcessStatusEntry for the store. */
@@ -93,11 +94,15 @@ function AddPanelMenuItems({
state,
onNewSession,
onAddTerminal,
onRunScript,
onRunDevScript,
}: {
groupId: string;
state: ReturnType<typeof useLeftHeaderState>;
onNewSession: () => void;
onAddTerminal: () => void;
onRunScript: (scriptId: string) => void;
onRunDevScript: () => void;
}) {
const addBrowserPanel = useDockviewStore((s) => s.addBrowserPanel);
const addVscodePanel = useDockviewStore((s) => s.addVscodePanel);
@@ -167,6 +172,7 @@ function AddPanelMenuItems({
{prPanelLabel(state.pr.pr_number)}
</DropdownMenuItem>
)}
<RepositoryScriptsMenuItems onRunScript={onRunScript} onRunDevScript={onRunDevScript} />
</>
);
}
@@ -175,6 +181,7 @@ export function LeftHeaderActions(props: IDockviewHeaderActionsProps) {
const { group, containerApi } = props;
const state = useLeftHeaderState(group.id, containerApi);
const addTerminalPanel = useDockviewStore((s) => s.addTerminalPanel);
const devScript = useActiveSessionDevScript();
const [showNewSessionDialog, setShowNewSessionDialog] = useState(false);
const handleAddTerminal = useCallback(async () => {
@@ -187,6 +194,32 @@ export function LeftHeaderActions(props: IDockviewHeaderActionsProps) {
}
}, [state.activeSessionId, addTerminalPanel, group.id]);
const handleRunScript = useCallback(
async (scriptId: string) => {
if (!state.activeSessionId) return;
try {
const result = await createUserShell(state.activeSessionId, { scriptId });
addTerminalPanel(result.terminalId, group.id);
} catch (error) {
console.error("Failed to run script:", error);
}
},
[state.activeSessionId, addTerminalPanel, group.id],
);
const handleRunDevScript = useCallback(async () => {
if (!state.activeSessionId || !devScript) return;
try {
const result = await createUserShell(state.activeSessionId, {
command: devScript,
label: "Dev Server",
});
addTerminalPanel(result.terminalId, group.id);
} catch (error) {
console.error("Failed to start dev script:", error);
}
}, [state.activeSessionId, devScript, addTerminalPanel, group.id]);
if (state.isSidebarGroup) return null;
return (
@@ -208,6 +241,8 @@ export function LeftHeaderActions(props: IDockviewHeaderActionsProps) {
state={state}
onNewSession={() => setShowNewSessionDialog(true)}
onAddTerminal={handleAddTerminal}
onRunScript={handleRunScript}
onRunDevScript={handleRunDevScript}
/>
</DropdownMenuContent>
</DropdownMenu>
@@ -472,18 +507,6 @@ function CenterRightActions() {
);
}
function useHasActiveSessionDevScript() {
return useAppStore((state) => {
const sessionId = state.tasks.activeSessionId;
if (!sessionId) return false;
const repoId = state.taskSessions.items[sessionId]?.repository_id;
if (!repoId) return false;
const allRepos = Object.values(state.repositories.itemsByWorkspaceId).flat();
const repo = allRepos.find((r) => r.id === repoId);
return Boolean(repo?.dev_script?.trim());
});
}
function TerminalGroupRightActions() {
const activeSessionId = useAppStore((state) => state.tasks.activeSessionId);
const repositoryId = useAppStore((state) => {
@@ -491,7 +514,7 @@ function TerminalGroupRightActions() {
if (!sessionId) return null;
return state.taskSessions.items[sessionId]?.repository_id ?? null;
});
const hasDevScript = useHasActiveSessionDevScript();
const hasDevScript = Boolean(useActiveSessionDevScript());
const { scripts } = useRepositoryScripts(repositoryId);
const addTerminalPanel = useDockviewStore((s) => s.addTerminalPanel);
@@ -504,7 +527,7 @@ function TerminalGroupRightActions() {
async (scriptId: string) => {
if (!activeSessionId) return;
try {
const result = await createUserShell(activeSessionId, scriptId);
const result = await createUserShell(activeSessionId, { scriptId });
addTerminalPanel(result.terminalId, rightBottomGroupId);
} catch (error) {
console.error("Failed to run script:", error);
@@ -0,0 +1,78 @@
"use client";
import { IconDeviceDesktop, IconPlayerPlay } from "@tabler/icons-react";
import {
DropdownMenuItem,
DropdownMenuLabel,
DropdownMenuSeparator,
} from "@kandev/ui/dropdown-menu";
import { useAppStore } from "@/components/state-provider";
import { useRepositoryScripts } from "@/hooks/domains/workspace/use-repository-scripts";
/**
* Returns the trimmed dev_script command of the active session's repository,
* or an empty string when none is configured. Boolean usage stays valid via
* truthiness; callers that need the command itself can use it directly.
*/
export function useActiveSessionDevScript(): string {
return useAppStore((state) => {
const sessionId = state.tasks.activeSessionId;
if (!sessionId) return "";
const repoId = state.taskSessions.items[sessionId]?.repository_id;
if (!repoId) return "";
const allRepos = Object.values(state.repositories.itemsByWorkspaceId).flat();
const repo = allRepos.find((r) => r.id === repoId);
return repo?.dev_script?.trim() ?? "";
});
}
/**
* Renders custom repository scripts (and the dev script if configured) as
* dropdown items inside the dockview "+" menu. Returns null when neither is
* available so the caller doesn't render an empty section.
*/
export function RepositoryScriptsMenuItems({
onRunScript,
onRunDevScript,
}: {
onRunScript: (scriptId: string) => void;
onRunDevScript: () => void;
}) {
const repositoryId = useAppStore((s) => {
const sessionId = s.tasks.activeSessionId;
if (!sessionId) return null;
return s.taskSessions.items[sessionId]?.repository_id ?? null;
});
const { scripts } = useRepositoryScripts(repositoryId);
const devScript = useActiveSessionDevScript();
if (scripts.length === 0 && !devScript) return null;
return (
<>
<DropdownMenuSeparator />
<DropdownMenuLabel className="text-xs text-muted-foreground">Scripts</DropdownMenuLabel>
{devScript && (
<DropdownMenuItem
onClick={onRunDevScript}
className="cursor-pointer text-xs"
data-testid="run-dev-script"
>
<IconDeviceDesktop className="h-3.5 w-3.5 mr-1.5 shrink-0" />
<span className="truncate">Dev Server</span>
</DropdownMenuItem>
)}
{scripts.map((script) => (
<DropdownMenuItem
key={script.id}
onClick={() => onRunScript(script.id)}
className="cursor-pointer text-xs"
data-testid={`run-script-${script.id}`}
>
<IconPlayerPlay className="h-3.5 w-3.5 mr-1.5 shrink-0" />
<span className="truncate">{script.name}</span>
</DropdownMenuItem>
))}
</>
);
}
+26
View File
@@ -370,6 +370,32 @@ export class ApiClient {
});
}
async updateRepository(
repositoryId: string,
updates: { dev_script?: string; setup_script?: string; cleanup_script?: string },
): Promise<void> {
await this.request("PATCH", `/api/v1/repositories/${repositoryId}`, updates);
}
async createRepositoryScript(
repositoryId: string,
name: string,
command: string,
position = 0,
): Promise<{
id: string;
repository_id: string;
name: string;
command: string;
position: number;
}> {
return this.request("POST", `/api/v1/repositories/${repositoryId}/scripts`, {
name,
command,
position,
});
}
async createExecutor(
name: string,
type: string,
@@ -0,0 +1,236 @@
import { type Page } from "@playwright/test";
import { test, expect } from "../../fixtures/test-base";
import type { SeedData } from "../../fixtures/test-base";
import type { ApiClient } from "../../helpers/api-client";
import { SessionPage } from "../../pages/session-page";
async function seedTaskWithSession(
testPage: Page,
apiClient: ApiClient,
seedData: SeedData,
title: string,
): Promise<SessionPage> {
const task = await apiClient.createTaskWithAgent(
seedData.workspaceId,
title,
seedData.agentProfileId,
{
description: "/e2e:simple-message",
workflow_id: seedData.workflowId,
workflow_step_id: seedData.startStepId,
repository_ids: [seedData.repositoryId],
},
);
if (!task.session_id) throw new Error("createTaskWithAgent did not return a session_id");
await testPage.goto(`/t/${task.id}`);
const session = new SessionPage(testPage);
await session.waitForLoad();
await expect(session.idleInput()).toBeVisible({ timeout: 30_000 });
return session;
}
/** Read the visible top-level menu items in the dockview "+" dropdown. */
async function readMenuItemTexts(testPage: Page): Promise<string[]> {
return testPage.locator('[role="menuitem"]:visible').allInnerTexts();
}
/**
* Read every xterm buffer on the page and return their concatenated text. Used
* to assert that *some* terminal contains given output regardless of which
* dockview group / tab order it ended up in.
*/
async function readAllTerminalBuffers(testPage: Page): Promise<string> {
return testPage.evaluate(() => {
type XC = HTMLElement & { __xtermReadBuffer?: () => string };
const panels = Array.from(document.querySelectorAll('[data-testid="terminal-panel"]'));
return panels
.map((panel) => {
const xtermEl = panel.querySelector(".xterm");
const container = xtermEl?.parentElement as XC | null | undefined;
return container?.__xtermReadBuffer?.() ?? "";
})
.join("\n----\n");
});
}
test.describe("Dockview repository scripts in + menu", () => {
test.describe.configure({ retries: 1 });
test("does not render Scripts section when repo has no scripts and no dev_script", async ({
testPage,
apiClient,
seedData,
}) => {
// Ensure repo has no dev_script (seed doesn't set one, but be explicit).
await apiClient.updateRepository(seedData.repositoryId, { dev_script: "" });
const session = await seedTaskWithSession(testPage, apiClient, seedData, "No Scripts");
await session.addPanelButton().click();
await expect(testPage.getByRole("menuitem", { name: "Terminal" })).toBeVisible();
await expect(testPage.getByText("Scripts", { exact: true })).toHaveCount(0);
await expect(testPage.getByTestId("run-dev-script")).toHaveCount(0);
});
test("renders custom scripts at the end of the + menu", async ({
testPage,
apiClient,
seedData,
}) => {
const buildScript = await apiClient.createRepositoryScript(
seedData.repositoryId,
"Run Build",
"echo build",
0,
);
const lintScript = await apiClient.createRepositoryScript(
seedData.repositoryId,
"Run Lint",
"echo lint",
1,
);
const session = await seedTaskWithSession(testPage, apiClient, seedData, "Custom Scripts");
await session.addPanelButton().click();
await expect(testPage.getByTestId(`run-script-${buildScript.id}`)).toBeVisible();
await expect(testPage.getByTestId(`run-script-${lintScript.id}`)).toBeVisible();
// Scripts must be the LAST items in the menu. Verify by ordering: the
// "Browser" item appears before the script items in the visible menu.
const items = await readMenuItemTexts(testPage);
const browserIdx = items.findIndex((t) => t.includes("Browser"));
const buildIdx = items.findIndex((t) => t.includes("Run Build"));
const lintIdx = items.findIndex((t) => t.includes("Run Lint"));
expect(browserIdx).toBeGreaterThanOrEqual(0);
expect(buildIdx).toBeGreaterThan(browserIdx);
expect(lintIdx).toBeGreaterThan(browserIdx);
});
test("clicking a custom script opens a terminal that runs the script command", async ({
testPage,
apiClient,
seedData,
}) => {
const marker = "CUSTOM_SCRIPT_RAN_OK_3131";
const script = await apiClient.createRepositoryScript(
seedData.repositoryId,
"Echo Hello",
`echo ${marker}`,
0,
);
const session = await seedTaskWithSession(testPage, apiClient, seedData, "Click Script");
await session.addPanelButton().click();
await testPage.getByTestId(`run-script-${script.id}`).click();
// The backend assigns script terminals an id prefixed with "script-".
await expect
.poll(
async () => {
return testPage.evaluate(() => {
type Panel = { id: string };
type Api = { panels: Panel[] };
const api = (window as unknown as { __dockviewApi__?: Api }).__dockviewApi__;
return api?.panels.some((p) => p.id.startsWith("script-")) ?? false;
});
},
{ timeout: 10_000, message: "Expected a script terminal panel to be added" },
)
.toBe(true);
// The script command must actually execute — *some* terminal buffer
// (the one belonging to the new script panel) must contain the marker.
await expect
.poll(async () => (await readAllTerminalBuffers(testPage)).includes(marker), {
timeout: 60_000,
message: `Expected a terminal to contain "${marker}"`,
})
.toBe(true);
});
test("renders Dev Server entry when repository has dev_script", async ({
testPage,
apiClient,
seedData,
}) => {
await apiClient.updateRepository(seedData.repositoryId, {
dev_script: "echo dev-server-running",
});
const session = await seedTaskWithSession(testPage, apiClient, seedData, "Dev Script");
await session.addPanelButton().click();
await expect(testPage.getByTestId("run-dev-script")).toBeVisible();
await expect(testPage.getByText("Dev Server", { exact: true })).toBeVisible();
// Also at the end of the menu — after Browser.
const items = await readMenuItemTexts(testPage);
const browserIdx = items.findIndex((t) => t.includes("Browser"));
const devIdx = items.findIndex((t) => t.includes("Dev Server"));
expect(devIdx).toBeGreaterThan(browserIdx);
});
test("dev_script and custom scripts coexist in the Scripts section", async ({
testPage,
apiClient,
seedData,
}) => {
await apiClient.updateRepository(seedData.repositoryId, { dev_script: "echo dev" });
const customScript = await apiClient.createRepositoryScript(
seedData.repositoryId,
"Test Suite",
"echo test",
0,
);
const session = await seedTaskWithSession(testPage, apiClient, seedData, "Mixed Scripts");
await session.addPanelButton().click();
await expect(testPage.getByTestId("run-dev-script")).toBeVisible();
await expect(testPage.getByTestId(`run-script-${customScript.id}`)).toBeVisible();
});
test("clicking Dev Server opens a terminal that runs the dev_script command", async ({
testPage,
apiClient,
seedData,
}) => {
const marker = "DEV_SCRIPT_RAN_OK_4242";
await apiClient.updateRepository(seedData.repositoryId, {
dev_script: `echo ${marker}`,
});
const session = await seedTaskWithSession(testPage, apiClient, seedData, "Run Dev Script");
await session.addPanelButton().click();
await testPage.getByTestId("run-dev-script").click();
// Backend assigns "script-"-prefixed ids to script terminals.
await expect
.poll(
async () => {
return testPage.evaluate(() => {
type Panel = { id: string };
type Api = { panels: Panel[] };
const api = (window as unknown as { __dockviewApi__?: Api }).__dockviewApi__;
return api?.panels.some((p) => p.id.startsWith("script-")) ?? false;
});
},
{ timeout: 10_000, message: "Expected a dev-script terminal panel to be added" },
)
.toBe(true);
// The dev_script must actually execute — *some* terminal buffer should
// contain the marker emitted by the script command.
await expect
.poll(async () => (await readAllTerminalBuffers(testPage)).includes(marker), {
timeout: 60_000,
message: `Expected a terminal to contain "${marker}"`,
})
.toBe(true);
});
});
@@ -272,7 +272,7 @@ function useTerminalActions({
async (script: RepositoryScript) => {
if (!sessionId) return;
try {
const result = await createUserShell(sessionId, script.id);
const result = await createUserShell(sessionId, { scriptId: script.id });
setTerminals((prev) => [
...prev,
{ id: result.terminalId, type: "script", label: result.label, closable: result.closable },
+15 -5
View File
@@ -44,15 +44,25 @@ export type CreateUserShellResult = {
initialCommand?: string;
};
/**
* Options for {@link createUserShell}. Pass `scriptId` to run a stored
* RepositoryScript, or `command` (with optional `label`) to run an arbitrary
* command — used for the repository's dev_script. Omit both for a plain shell.
*/
export type CreateUserShellOptions = {
scriptId?: string;
command?: string;
label?: string;
};
/**
* Create a new user shell terminal.
* Backend assigns the terminal ID, label, and closable status.
* First terminal is "Terminal" and not closable, subsequent are "Terminal 2", etc. and closable.
* If scriptId is provided, creates a script terminal with the script's name and command.
*/
export async function createUserShell(
sessionId: string,
scriptId?: string,
options?: CreateUserShellOptions,
): Promise<CreateUserShellResult> {
const client = getWebSocketClient();
if (!client) {
@@ -60,9 +70,9 @@ export async function createUserShell(
}
const payload: Record<string, string> = { session_id: sessionId };
if (scriptId) {
payload.script_id = scriptId;
}
if (options?.scriptId) payload.script_id = options.scriptId;
if (options?.command) payload.command = options.command;
if (options?.label) payload.label = options.label;
const response = (await client.request("user_shell.create", payload)) as {
terminal_id: string;