@leg3ndy/otto-bridge 1.0.12 → 1.1.1

package/README.md

@@ -15,7 +15,7 @@ Para o estado atual da arquitetura, capacidades entregues, limitacoes e roadmap
 
 Para o corte de arquitetura do `0.9.0`, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_0_9_0_RELEASE.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_0_9_0_RELEASE.md).
 
-Para a release atual `1.0.12`, com composer TTY simplificado para um prompt multiline sem moldura, cursor alinhado ao placeholder e newline sem abrir caixas duplicadas, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_0_12_PATCH.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_0_12_PATCH.md).
+Para o patch atual `1.1.1`, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_1_PATCH.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_1_PATCH.md). Para o corte funcional da linha `1.1.0`, veja [`leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_0_RELEASE.md`](../leg3ndy-ai-backend/docs/otto-bridge/releases/OTTO_BRIDGE_1_1_0_RELEASE.md).
 
 ## Distribuicao
 
@@ -38,14 +38,14 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-1.0.12.tgz
+npm install -g ./leg3ndy-otto-bridge-1.1.1.tgz
 ```
 
-Na linha `1.0.12`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
+Na linha `1.1.1`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
 
-No macOS, a linha `1.0.12` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
+No macOS, a linha `1.1.1` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
 
-No nivel arquitetural, o `0.9.0` marcou a mudanca de papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat. O `1.0.0` oficializou isso como runtime agentico; o `1.0.12` preserva esse fluxo, simplifica o prompt TTY para evitar artefatos de moldura em terminais mais temperamentais, mantem o composer multiline e melhora as views de status/extensoes e o refresh ao sair do `Terminal`.
+No nivel arquitetural, o `0.9.0` marcou a mudanca de papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat. O `1.0.0` oficializou isso como runtime agentico; o `1.1.1` adiciona a camada workspace-first com rail de coding, trust/policy por workspace, source control first-class, working set persistido e grounding remoto por repositório.
 
 ## Publicacao
 
@@ -84,6 +84,8 @@ otto-bridge
 
 Em TTY, o comando sem argumentos agora abre o hub interativo com banner, setup, status, extensoes e o `Otto Console`. Se ja existir pairing salvo, o próprio `otto-bridge` sobe o runtime local automaticamente e mostra o estado da conexão no hub.
 
+Na web, o acesso ao Otto Bridge fica no botao com icone de estrela/brilho ao lado do botao de anexos.
+
 ### Setup interativo
 
 ```bash
@@ -92,6 +94,8 @@ otto-bridge setup
 
 Esse fluxo pede `API base URL`, `pairing code`, nome do dispositivo e executor. Em install global interativo, o pacote tambem tenta abrir esse setup automaticamente quando ainda nao existe pairing salvo.
 
+O `pairing code` e gerado no modal do Otto Bridge aberto pela interface web, no botao com icone de estrela ao lado de anexos.
+
 ### Parear o dispositivo
 
 ```bash
@@ -141,7 +145,15 @@ Dentro do console, use:
 
 - `/model fast` para `OttoAI Fast`
 - `/model thinking` para `OttoAI Thinking`
+- `/approval preview`, `/approval confirm` ou `/approval trusted` para trocar o modo de aprovação do device
 - `/status` para ver detalhes técnicos do bridge e do runtime
+- `/workspace` ou `/workspace status` para ver o workspace ativo desta sessão
+- `/workspace list` para listar workspaces anexados ao device
+- `/workspace attach <path>` para anexar uma pasta/repo novo pelo helper autenticado
+- `/workspace use <id|n>` para fixar um workspace anexado na sessão atual
+- `/workspace clear` para limpar o binding atual do chat/sessão
+
+No TTY, o composer agora fica ancorado no rodapé com placeholder `Peça algo ao Otto`, quebra por largura real do terminal e deixa o transcript do Otto sempre visível acima. Logo abaixo do input, o console mostra o modelo ativo, a barra de uso de contexto/tokens e o modo de aprovação atual; `Shift+Tab` alterna esse modo sem sair do console.
 
 No modo `OttoAI Thinking`, o terminal agora marca explicitamente o trecho de raciocínio com `Pensando (OttoAI Thinking)` e separa esse bloco da resposta final do Otto.
 
@@ -157,7 +169,7 @@ Esse comando abre um shell local interativo para instalar extensoes, rodar coman
 
 ### WhatsApp Web em background
 
-Fluxo recomendado na linha `1.0.12`:
+Fluxo recomendado na linha `1.1.1`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -167,13 +179,13 @@ otto-bridge extensions --status whatsappweb
 
 O setup agora abre o login do WhatsApp Web no helper/background browser do proprio bridge. Depois do QR code, o Otto usa a sessao local em background, sem depender de aba visivel no Safari.
 
-Contrato da linha `1.0.12`:
+Contrato da linha `1.1.1`:
 
 - `otto-bridge extensions --setup whatsappweb`: autentica a sessao uma vez
 - `otto-bridge`: mantem o browser persistente do WhatsApp vivo em background enquanto o runtime do hub estiver ativo, sem depender de uma aba aberta no Safari
 - ao fechar o `otto-bridge`: o browser em background e desligado, mas a sessao local fica lembrada para o proximo boot
 
-## Handoff rapido da linha 1.0.12
+## Handoff rapido da linha 1.1.1
 
 Ja fechado no codigo:
 
@@ -187,8 +199,10 @@ Ja fechado no codigo:
 - o executor `native-macos` agora reporta o step atual por acao e publica inline artifacts estruturados para resultados locais nao-uploadados
 - o `runtime_contract` agora pode declarar `workspace_context` com roots/targets e descriptors de `instruction_bundle`, `repo_manifest`, `workspace_index`, `workspace_memory` e `workspace_policy` para jobs de arquivo e shell
 - o bridge agora resolve `workspace_context` em paths absolutos, detecta `repo_root`, carrega `AGENTS.md` por precedencia e publica `instruction_bundle`, `repo_manifest`, `workspace_index`, `workspace_memory` e `workspace_policy` no resultado
+- workspaces anexados pelo modal web agora tambem viram parte do metadata do helper: o `otto-bridge` consulta `/v1/devices/runtime/workspaces` com `device_token`, sonda localmente `repo_root`, `branch` e a cadeia de `AGENTS.md` antes do `device.hello`, e reage a `device.metadata.refresh` para republicar esse snapshot quando o usuario anexa/remove um workspace com o bridge online
 - filesystem e shell locais agora respeitam os roots declarados do workspace, em vez de operar como superficie global quando o job vier escopado
 - `workspace_policy` agora aplica perfis `observe_only`, `dev_assist`, `workspace_coding` e `release_operator` antes da execucao local de actions escopadas
+- cada workspace anexado agora tambem persiste o proprio `policy_profile_id`; o modal do Otto Bridge permite trocar esse perfil, o banner do chat mostra o trust atual e o runtime trata esse valor como teto real da sessao antes de shell, patch, delete ou release
 - `write_json_file`, `mkdir`, `move_file` e `delete_file` agora fazem parte da familia inicial de file ops tipadas do workspace
 - `workspace.patch`, `git.clone`, `git.fetch`, `git.checkout`, `git.rebase`, `git.merge`, `git.tag`, `git.status`, `git.diff`, `git.stage`, `git.commit`, `git.push` e `workspace.tests` agora fazem parte da primeira familia tipada de coding agent do catalogo local
 - `apply_patch`, `git_status`, `git_diff`, `run_tests`, `git_clone`, `git_fetch`, `git_checkout`, `git_rebase`, `git_merge`, `git_tag`, `git_add`, `git_commit` e `git_push` agora executam dentro do workspace escopado e devolvem snapshots estruturados em vez de shell cru
@@ -207,6 +221,10 @@ Ja fechado no codigo:
 - o `instruction_updater` agora e um descriptor explicito do runtime, com `source_entrypoints`, `target_paths` e `recommended_validation_stage_ids` quando o plano toca `AGENTS.md`, `README.md` ou `docs/`
 - `workspace.tests` agora consegue resolver `profile=auto` via `validation_ladder`, executando stages como `typecheck`, `build`, `node_test`, `lint` e `pytest` por stack, com snapshot agregado por etapa
 - o executor `native-macos` agora publica `runtime_hook_trace` somando hooks de lifecycle e tool-use (`session_start`, `pre_tool_use`, `post_tool_use`, `validation_ladder_started/completed`, `session_end`), preparando enforcement, replay fino e metricas futuras
+- o frontend agora consome `runtime_hook_trace`, `runtime_replay` e o progresso corrente como feed inline persistente no chat, para o usuario ver o Otto lendo, procurando, editando, validando e concluindo em tempo real
+- o chat web agora mostra esse plano/checklist acima do input enquanto o job local roda, e deixa o bloco detalhado de runtime apenas para o resultado final quando houver detalhe real de arquivo/diff/source control/validacao/erro
+- o catalogo local agora inclui `filesystem.open_path`, usado para abrir um arquivo/pasta local no app padrao do macOS ou revelar no Finder a partir dos links clicaveis do timeline
+- o modal do Otto Bridge agora mostra `Jobs locais` em resumo textual, `Snapshot do workspace` com source control/validacao/working set e links de path que disparam `open_path` local, sem repetir a timeline detalhada do chat
 - o bridge agora possui um CLI interativo proprio com setup inicial, hub terminal e `Otto Console` para conversar com o Otto pelo proprio terminal
 - o backend agora expoe caminhos `device-auth` para o console do bridge usar chat com quota/plano (`/v1/devices/cli/chat/completions`) e acompanhar approval/job usando apenas `device_token`
 - o caminho principal do bridge usa `summary`/`narration_context` no lugar de resposta automatica pronta

package/dist/agentic_runtime/workspace/manager.js

@@ -245,6 +245,12 @@ function normalizeWorkspacePolicy(value, workspaceId, actionTypes, destructiveAc
     const title = asString(value?.title) || WORKSPACE_POLICY_TITLES[profileId] || "Workspace Policy";
     const summary = asString(value?.summary)
         || `Policy ${profileId} carregada para o workspace ${workspaceId} com ${allowedActionTypes.length} action types permitidos.`;
+    const rationale = asString(value?.rationale)
+        || (normalizedActionTypes.length > 0
+            ? value?.profile_id
+                ? `Perfil ${profileId} aplicado ao workspace para actions do runtime: ${normalizedActionTypes.join(", ")}.`
+                : `Perfil inferido a partir das actions do runtime: ${normalizedActionTypes.join(", ")}.`
+            : undefined);
     return {
         profile_id: profileId || "observe_only",
         title,
@@ -252,9 +258,7 @@ function normalizeWorkspacePolicy(value, workspaceId, actionTypes, destructiveAc
         allowed_action_types: allowedActionTypes,
         blocked_action_types: blockedActionTypes,
         requires_confirmation_action_types: requiresConfirmationActionTypes,
-        rationale: asString(value?.rationale) || (normalizedActionTypes.length > 0
-            ? `Perfil inferido a partir das actions do runtime: ${normalizedActionTypes.join(", ")}.`
-            : undefined),
+        rationale,
         allow_shell: allowShell,
         allow_code_write: allowCodeWrite,
         allow_destructive: allowDestructive,
@@ -1036,9 +1040,9 @@ export function assertActionAllowedByWorkspacePolicy(workspace, actionType) {
         return;
     }
     if (workspacePolicy.blocked_action_types.includes(normalizedActionType)) {
-        throw new Error(`A action ${normalizedActionType} foi bloqueada pela policy ${workspacePolicy.profile_id} do workspace ${workspace.workspaceId}.`);
+        throw new Error(`A policy ${workspacePolicy.profile_id} deste workspace bloqueia a action ${normalizedActionType}. Troque o perfil de confiança do workspace para liberar essa operação.`);
     }
     if (!workspacePolicy.allowed_action_types.includes(normalizedActionType)) {
-        throw new Error(`A action ${normalizedActionType} nao esta permitida pela policy ${workspacePolicy.profile_id} do workspace ${workspace.workspaceId}.`);
+        throw new Error(`A action ${normalizedActionType} nao está permitida no perfil ${workspacePolicy.profile_id} deste workspace. Ajuste a policy do workspace para permitir essa operação.`);
     }
 }

package/dist/attached_workspaces.js

@@ -0,0 +1,259 @@
+import { execFile } from "node:child_process";
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { deleteDeviceJson, getDeviceJson, postDeviceJson } from "./http.js";
+import { resolveWorkspaceContext, expandUserPathLike } from "./agentic_runtime/workspace/manager.js";
+const execFileAsync = promisify(execFile);
+const DEFAULT_IGNORED_DIRECTORY_NAMES = [
+    ".git",
+    ".next",
+    ".venv",
+    "__pycache__",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "venv",
+];
+const DEFAULT_KEY_FILE_PATTERNS = [
+    "AGENTS.md",
+    "README.md",
+    "package.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "Cargo.toml",
+    "go.mod",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock",
+];
+function asString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.map((item) => asString(item)).filter(Boolean)));
+}
+function slugifyWorkspaceToken(value) {
+    const slug = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    return slug.slice(0, 120) || "workspace_local";
+}
+function deriveWorkspaceLabel(rootPath) {
+    const normalized = rootPath.replace(/[\\/]+$/, "");
+    const basename = path.basename(normalized);
+    return basename || normalized || "Workspace local";
+}
+function normalizeAttachedWorkspaceCandidate(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const payload = value;
+    const rootPath = asString(payload.root_path)
+        || asString(payload.path)
+        || asString(payload.workspace_root);
+    if (!rootPath) {
+        return null;
+    }
+    const workspaceId = asString(payload.workspace_id) || `workspace_${slugifyWorkspaceToken(rootPath)}`;
+    return {
+        workspace_id: workspaceId,
+        label: asString(payload.label) || asString(payload.name) || deriveWorkspaceLabel(rootPath),
+        root_path: rootPath,
+        repo_root: asString(payload.repo_root) || rootPath,
+        branch: asString(payload.branch) || null,
+        is_git_repo: Boolean(payload.is_git_repo),
+        agents_loaded: payload.agents_loaded === true,
+        agents_paths: Array.isArray(payload.agents_paths)
+            ? uniqueStrings(payload.agents_paths)
+            : [],
+        policy_profile_id: asString(payload.policy_profile_id) || asString(payload.workspace_policy_profile) || "workspace_coding",
+        policy_updated_at: asString(payload.policy_updated_at) || null,
+        updated_at: asString(payload.updated_at) || null,
+    };
+}
+async function resolveWorkspaceRootPath(rootPath, baseCwd) {
+    const expanded = expandUserPathLike(rootPath, baseCwd);
+    try {
+        const fileStat = await stat(expanded);
+        if (fileStat.isFile()) {
+            return path.dirname(expanded);
+        }
+    }
+    catch {
+        return expanded;
+    }
+    return expanded;
+}
+async function readGitBranch(repoRoot) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", repoRoot, "branch", "--show-current"], {
+            timeout: 4000,
+        });
+        const branch = asString(stdout);
+        return branch || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function probeAttachedWorkspace(workspace, options) {
+    const resolvedRootPath = await resolveWorkspaceRootPath(workspace.root_path, options?.baseCwd);
+    const resolvedWorkspace = await resolveWorkspaceContext({
+        baseCwd: options?.baseCwd,
+        workspaceContext: {
+            workspace_id: workspace.workspace_id,
+            roots: [
+                {
+                    root_id: "workspace_root_01",
+                    path: resolvedRootPath,
+                    kind: "declared_path",
+                    scope_reason: "attached_workspace_root",
+                    action_types: ["filesystem_inspect"],
+                    source: "bridge_attached_workspace_probe",
+                },
+            ],
+            targets: [
+                {
+                    target_id: "workspace_target_01",
+                    path: resolvedRootPath,
+                    kind: "directory",
+                    access_mode: "enumerate",
+                    action_type: "filesystem_inspect",
+                    source: "bridge_attached_workspace_probe",
+                },
+            ],
+            instruction_bundle: {
+                resolver: "bridge_local_agents_md",
+                entrypoints: ["AGENTS.md"],
+                precedence: [
+                    "nearest_target_agents_md",
+                    "workspace_repo_agents_md",
+                    "monorepo_root_agents_md",
+                ],
+            },
+            repo_manifest: {
+                resolver: "bridge_workspace_repo_probe",
+                marker_paths: [".git"],
+                manifest_paths: ["AGENTS.md", "README.md", "package.json", "pyproject.toml", "requirements.txt", "Cargo.toml", "go.mod"],
+                lockfile_paths: ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb", "poetry.lock", "Pipfile.lock", "Cargo.lock", "go.sum"],
+                include_instruction_sources: true,
+                vcs_hint: "git",
+            },
+            workspace_index: {
+                resolver: "bridge_workspace_scan_light",
+                max_depth: 1,
+                max_directories: 8,
+                max_files: 32,
+                ignored_directory_names: DEFAULT_IGNORED_DIRECTORY_NAMES,
+                key_file_patterns: DEFAULT_KEY_FILE_PATTERNS,
+            },
+        },
+    });
+    const repoRoot = resolvedWorkspace?.repoRoot || resolvedRootPath;
+    const branch = resolvedWorkspace?.repoRoot
+        ? await readGitBranch(resolvedWorkspace.repoRoot).catch(() => null)
+        : null;
+    const agentsPaths = resolvedWorkspace?.instructionBundle?.sources.map((item) => item.path) || [];
+    return {
+        workspace_id: workspace.workspace_id,
+        label: workspace.label || deriveWorkspaceLabel(resolvedRootPath),
+        root_path: resolvedRootPath,
+        repo_root: repoRoot,
+        branch: branch || workspace.branch || null,
+        is_git_repo: Boolean(resolvedWorkspace?.repoRoot),
+        agents_loaded: agentsPaths.length > 0,
+        agents_paths: agentsPaths,
+        policy_profile_id: workspace.policy_profile_id || "workspace_coding",
+        policy_updated_at: workspace.policy_updated_at || workspace.updated_at || null,
+        updated_at: new Date().toISOString(),
+    };
+}
+export async function loadAttachedWorkspacesForHello(options) {
+    const fallbackCandidates = Array.isArray(options.fallbackMetadata?.attached_workspaces)
+        ? options.fallbackMetadata?.attached_workspaces || []
+        : [];
+    let rawCandidates = fallbackCandidates;
+    try {
+        const response = await getDeviceJson(options.apiBaseUrl, options.deviceToken, "/v1/devices/runtime/workspaces");
+        if (Array.isArray(response.workspaces)) {
+            rawCandidates = response.workspaces;
+        }
+    }
+    catch {
+        // Fall back to whatever the local config already knows.
+    }
+    const candidates = rawCandidates
+        .map((item) => normalizeAttachedWorkspaceCandidate(item))
+        .filter((item) => Boolean(item));
+    if (candidates.length === 0) {
+        return [];
+    }
+    const probed = await Promise.all(candidates.map(async (workspace) => {
+        try {
+            return await probeAttachedWorkspace(workspace, { baseCwd: options.baseCwd });
+        }
+        catch {
+            return {
+                ...workspace,
+                root_path: expandUserPathLike(workspace.root_path, options.baseCwd),
+                updated_at: new Date().toISOString(),
+            };
+        }
+    }));
+    return probed;
+}
+export async function listAttachedWorkspacesForRuntime(options) {
+    return await loadAttachedWorkspacesForHello({
+        apiBaseUrl: options.apiBaseUrl,
+        deviceToken: options.deviceToken,
+        baseCwd: options.baseCwd,
+    });
+}
+export async function getRuntimeSessionWorkspace(options) {
+    const sessionId = asString(options.sessionId);
+    if (!sessionId) {
+        return null;
+    }
+    const response = await getDeviceJson(options.apiBaseUrl, options.deviceToken, `/v1/devices/runtime/sessions/${encodeURIComponent(sessionId)}/workspace`);
+    const workspace = normalizeAttachedWorkspaceCandidate(response.workspace);
+    if (!workspace) {
+        return null;
+    }
+    return await probeAttachedWorkspace(workspace, { baseCwd: options.baseCwd });
+}
+export async function attachWorkspaceForRuntime(options) {
+    const response = await postDeviceJson(options.apiBaseUrl, options.deviceToken, "/v1/devices/runtime/workspaces/attach", {
+        root_path: options.rootPath,
+        label: asString(options.label) || undefined,
+        repo_root: asString(options.repoRoot) || undefined,
+        branch: asString(options.branch) || undefined,
+    });
+    const workspace = normalizeAttachedWorkspaceCandidate(response.workspace);
+    if (!workspace) {
+        throw new Error("Workspace anexado sem payload válido.");
+    }
+    return await probeAttachedWorkspace(workspace, { baseCwd: options.baseCwd });
+}
+export async function activateWorkspaceForRuntime(options) {
+    const workspaceId = asString(options.workspaceId);
+    const sessionId = asString(options.sessionId);
+    if (!workspaceId || !sessionId) {
+        throw new Error("Workspace e sessão são obrigatórios para ativar o contexto do console.");
+    }
+    const response = await postDeviceJson(options.apiBaseUrl, options.deviceToken, `/v1/devices/runtime/workspaces/${encodeURIComponent(workspaceId)}/activate`, { session_id: sessionId });
+    const workspace = normalizeAttachedWorkspaceCandidate(response.workspace);
+    if (!workspace) {
+        return null;
+    }
+    return await probeAttachedWorkspace(workspace, { baseCwd: options.baseCwd });
+}
+export async function clearRuntimeWorkspaceForSession(options) {
+    const sessionId = asString(options.sessionId);
+    if (!sessionId) {
+        return;
+    }
+    await deleteDeviceJson(options.apiBaseUrl, options.deviceToken, `/v1/devices/runtime/sessions/${encodeURIComponent(sessionId)}/workspace`);
+}