npm - @gricha/perry - Versions diffs - 0.2.1 → 0.2.2 - Mend

@gricha/perry 0.2.1 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/README.md +18 -2
package/dist/agent/router.js +226 -87
package/dist/agent/run.js +53 -4
package/dist/agent/web/assets/index-DIOWcVH-.css +1 -0
package/dist/agent/web/assets/index-DN_QW9sL.js +104 -0
package/dist/agent/web/index.html +2 -2
package/dist/index.js +42 -0
package/dist/perry-worker +0 -0
package/dist/sessions/agents/claude.js +19 -0
package/dist/sessions/agents/codex.js +40 -0
package/dist/sessions/agents/index.js +63 -0
package/dist/sessions/agents/opencode-storage.js +218 -0
package/dist/sessions/agents/opencode.js +17 -3
package/dist/sessions/cache.js +5 -0
package/dist/shared/constants.js +1 -1
package/dist/tailscale/index.js +80 -0
package/dist/workspace/manager.js +40 -2
package/package.json +3 -2
package/dist/agent/web/assets/index-CGJDysKS.css +0 -1
package/dist/agent/web/assets/index-CwCl9DVw.js +0 -104

package/dist/agent/web/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/x-icon" href="/favicon.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Perry</title>
-    <script type="module" crossorigin src="/assets/index-CwCl9DVw.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CGJDysKS.css">
+    <script type="module" crossorigin src="/assets/index-DN_QW9sL.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DIOWcVH-.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/index.js CHANGED Viewed

@@ -201,6 +201,12 @@ program
             console.log(`  Uptime: ${formatUptime(info.uptime)}`);
             console.log(`  Workspaces: ${info.workspacesCount}`);
             console.log(`  Docker: ${info.dockerVersion}`);
+            if (info.tailscale?.running) {
+                console.log(`  Tailscale: ${info.tailscale.dnsName}`);
+                if (info.tailscale.httpsUrl) {
+                    console.log(`  HTTPS URL: ${info.tailscale.httpsUrl}`);
+                }
+            }
         }
     }
     catch (err) {
@@ -599,6 +605,42 @@ program
         process.exit(1);
     }
 });
+const workerCmd = program
+    .command('worker')
+    .description('Worker mode commands (for use inside containers)');
+workerCmd
+    .command('sessions')
+    .argument('<subcommand>', 'Subcommand: list, messages, or delete')
+    .argument('[sessionId]', 'Session ID (required for messages and delete)')
+    .description('Manage OpenCode sessions')
+    .action(async (subcommand, sessionId) => {
+    const { listOpencodeSessions, getOpencodeSessionMessages, deleteOpencodeSession } = await import('./sessions/agents/opencode-storage');
+    if (subcommand === 'list') {
+        const sessions = await listOpencodeSessions();
+        console.log(JSON.stringify(sessions));
+    }
+    else if (subcommand === 'messages') {
+        if (!sessionId) {
+            console.error('Usage: perry worker sessions messages <session_id>');
+            process.exit(1);
+        }
+        const result = await getOpencodeSessionMessages(sessionId);
+        console.log(JSON.stringify(result));
+    }
+    else if (subcommand === 'delete') {
+        if (!sessionId) {
+            console.error('Usage: perry worker sessions delete <session_id>');
+            process.exit(1);
+        }
+        const result = await deleteOpencodeSession(sessionId);
+        console.log(JSON.stringify(result));
+    }
+    else {
+        console.error(`Unknown subcommand: ${subcommand}`);
+        console.error('Available: list, messages, delete');
+        process.exit(1);
+    }
+});
 function handleError(err) {
     if (err instanceof ApiClientError) {
         console.error(`Error: ${err.message}`);

package/dist/perry-worker ADDED Viewed

Binary file

package/dist/sessions/agents/claude.js CHANGED Viewed

@@ -83,4 +83,23 @@ export const claudeProvider = {
             (msg.content && msg.content.trim().length > 0));
         return { id: sessionId, messages };
     },
+    async deleteSession(containerName, sessionId, exec) {
+        const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_-]/g, '');
+        const findResult = await exec(containerName, [
+            'bash',
+            '-c',
+            `find /home/workspace/.claude/projects -name "${safeSessionId}.jsonl" -type f 2>/dev/null | head -1`,
+        ], { user: 'workspace' });
+        if (findResult.exitCode !== 0 || !findResult.stdout.trim()) {
+            return { success: false, error: 'Session not found' };
+        }
+        const filePath = findResult.stdout.trim();
+        const rmResult = await exec(containerName, ['rm', '-f', filePath], {
+            user: 'workspace',
+        });
+        if (rmResult.exitCode !== 0) {
+            return { success: false, error: rmResult.stderr || 'Failed to delete session file' };
+        }
+        return { success: true };
+    },
 };

package/dist/sessions/agents/codex.js CHANGED Viewed

@@ -107,4 +107,44 @@ export const codexProvider = {
         }
         return null;
     },
+    async deleteSession(containerName, sessionId, exec) {
+        const findResult = await exec(containerName, ['bash', '-c', `find /home/workspace/.codex/sessions -name "*.jsonl" -type f 2>/dev/null`], { user: 'workspace' });
+        if (findResult.exitCode !== 0 || !findResult.stdout.trim()) {
+            return { success: false, error: 'No session files found' };
+        }
+        const files = findResult.stdout.trim().split('\n').filter(Boolean);
+        for (const file of files) {
+            const fileId = file.split('/').pop()?.replace('.jsonl', '') || '';
+            if (fileId === sessionId) {
+                const rmResult = await exec(containerName, ['rm', '-f', file], {
+                    user: 'workspace',
+                });
+                if (rmResult.exitCode !== 0) {
+                    return { success: false, error: rmResult.stderr || 'Failed to delete session file' };
+                }
+                return { success: true };
+            }
+            const headResult = await exec(containerName, ['head', '-1', file], {
+                user: 'workspace',
+            });
+            if (headResult.exitCode === 0) {
+                try {
+                    const meta = JSON.parse(headResult.stdout);
+                    if (meta.session_id === sessionId) {
+                        const rmResult = await exec(containerName, ['rm', '-f', file], {
+                            user: 'workspace',
+                        });
+                        if (rmResult.exitCode !== 0) {
+                            return { success: false, error: rmResult.stderr || 'Failed to delete session file' };
+                        }
+                        return { success: true };
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        return { success: false, error: 'Session not found' };
+    },
 };

package/dist/sessions/agents/index.js CHANGED Viewed

@@ -42,3 +42,66 @@ export async function findSessionMessages(containerName, sessionId, exec) {
     }
     return null;
 }
+export async function deleteSession(containerName, sessionId, agentType, exec) {
+    const provider = providers[agentType];
+    if (!provider) {
+        return { success: false, error: 'Unknown agent type' };
+    }
+    return provider.deleteSession(containerName, sessionId, exec);
+}
+export async function searchSessions(containerName, query, exec) {
+    const safeQuery = query.replace(/['"\\]/g, '\\$&');
+    const searchPaths = [
+        '/home/workspace/.claude/projects',
+        '/home/workspace/.local/share/opencode/storage',
+        '/home/workspace/.codex/sessions',
+    ];
+    const rgCommand = `rg -l -i --no-messages "${safeQuery}" ${searchPaths.join(' ')} 2>/dev/null | head -100`;
+    const result = await exec(containerName, ['bash', '-c', rgCommand], {
+        user: 'workspace',
+    });
+    if (result.exitCode !== 0 || !result.stdout.trim()) {
+        return [];
+    }
+    const files = result.stdout.trim().split('\n').filter(Boolean);
+    const results = [];
+    for (const file of files) {
+        let sessionId = null;
+        let agentType = null;
+        if (file.includes('/.claude/projects/')) {
+            const match = file.match(/\/([^/]+)\.jsonl$/);
+            if (match && !match[1].startsWith('agent-')) {
+                sessionId = match[1];
+                agentType = 'claude-code';
+            }
+        }
+        else if (file.includes('/.local/share/opencode/storage/')) {
+            if (file.includes('/session/') && file.endsWith('.json')) {
+                const match = file.match(/\/(ses_[^/]+)\.json$/);
+                if (match) {
+                    sessionId = match[1];
+                    agentType = 'opencode';
+                }
+            }
+            else if (file.includes('/part/') || file.includes('/message/')) {
+                continue;
+            }
+        }
+        else if (file.includes('/.codex/sessions/')) {
+            const match = file.match(/\/([^/]+)\.jsonl$/);
+            if (match) {
+                sessionId = match[1];
+                agentType = 'codex';
+            }
+        }
+        if (sessionId && agentType) {
+            results.push({
+                sessionId,
+                agentType,
+                filePath: file,
+                matchCount: 1,
+            });
+        }
+    }
+    return results;
+}

package/dist/sessions/agents/opencode-storage.js ADDED Viewed

@@ -0,0 +1,218 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+function getStorageBase(homeDir) {
+    const home = homeDir || os.homedir();
+    return path.join(home, '.local', 'share', 'opencode', 'storage');
+}
+export async function listOpencodeSessions(homeDir) {
+    const storageBase = getStorageBase(homeDir);
+    const sessionDir = path.join(storageBase, 'session');
+    const sessions = [];
+    try {
+        const projectDirs = await fs.readdir(sessionDir, { withFileTypes: true });
+        for (const projectDir of projectDirs) {
+            if (!projectDir.isDirectory())
+                continue;
+            const projectPath = path.join(sessionDir, projectDir.name);
+            const sessionFiles = await fs.readdir(projectPath);
+            for (const sessionFile of sessionFiles) {
+                if (!sessionFile.startsWith('ses_') || !sessionFile.endsWith('.json'))
+                    continue;
+                const filePath = path.join(projectPath, sessionFile);
+                try {
+                    const stat = await fs.stat(filePath);
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const data = JSON.parse(content);
+                    if (!data.id)
+                        continue;
+                    sessions.push({
+                        id: data.id,
+                        title: data.title || '',
+                        directory: data.directory || '',
+                        mtime: data.time?.updated || Math.floor(stat.mtimeMs),
+                        file: filePath,
+                    });
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    catch {
+        // Storage doesn't exist
+    }
+    return sessions;
+}
+export async function getOpencodeSessionMessages(sessionId, homeDir) {
+    const storageBase = getStorageBase(homeDir);
+    const sessionDir = path.join(storageBase, 'session');
+    const messageDir = path.join(storageBase, 'message');
+    const partDir = path.join(storageBase, 'part');
+    const sessionFile = await findSessionFile(sessionDir, sessionId);
+    if (!sessionFile) {
+        return { id: sessionId, messages: [] };
+    }
+    let internalId;
+    try {
+        const content = await fs.readFile(sessionFile, 'utf-8');
+        const data = JSON.parse(content);
+        internalId = data.id;
+        if (!internalId) {
+            return { id: sessionId, messages: [] };
+        }
+    }
+    catch {
+        return { id: sessionId, messages: [] };
+    }
+    const msgDir = path.join(messageDir, internalId);
+    const messages = [];
+    try {
+        const msgFiles = (await fs.readdir(msgDir))
+            .filter((f) => f.startsWith('msg_') && f.endsWith('.json'))
+            .sort();
+        for (const msgFile of msgFiles) {
+            const msgPath = path.join(msgDir, msgFile);
+            try {
+                const content = await fs.readFile(msgPath, 'utf-8');
+                const msg = JSON.parse(content);
+                if (!msg.id || (msg.role !== 'user' && msg.role !== 'assistant'))
+                    continue;
+                const partMsgDir = path.join(partDir, msg.id);
+                try {
+                    const partFiles = (await fs.readdir(partMsgDir))
+                        .filter((f) => f.startsWith('prt_') && f.endsWith('.json'))
+                        .sort();
+                    for (const partFile of partFiles) {
+                        const partPath = path.join(partMsgDir, partFile);
+                        try {
+                            const partContent = await fs.readFile(partPath, 'utf-8');
+                            const part = JSON.parse(partContent);
+                            const timestamp = msg.time?.created
+                                ? new Date(msg.time.created).toISOString()
+                                : undefined;
+                            if (part.type === 'text' && part.text) {
+                                messages.push({
+                                    type: msg.role,
+                                    content: part.text,
+                                    timestamp,
+                                });
+                            }
+                            else if (part.type === 'tool') {
+                                const toolName = part.state?.title || part.tool || '';
+                                const callId = part.callID || part.id || '';
+                                messages.push({
+                                    type: 'tool_use',
+                                    toolName,
+                                    toolId: callId,
+                                    toolInput: part.state?.input ? JSON.stringify(part.state.input) : '',
+                                    timestamp,
+                                });
+                                if (part.state?.output) {
+                                    messages.push({
+                                        type: 'tool_result',
+                                        content: part.state.output,
+                                        toolId: callId,
+                                        timestamp,
+                                    });
+                                }
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        // No messages
+    }
+    return { id: sessionId, messages };
+}
+async function findSessionFile(sessionDir, sessionId) {
+    try {
+        const projectDirs = await fs.readdir(sessionDir, { withFileTypes: true });
+        for (const projectDir of projectDirs) {
+            if (!projectDir.isDirectory())
+                continue;
+            const filePath = path.join(sessionDir, projectDir.name, `${sessionId}.json`);
+            try {
+                await fs.access(filePath);
+                return filePath;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist
+    }
+    return null;
+}
+export async function deleteOpencodeSession(sessionId, homeDir) {
+    const storageBase = getStorageBase(homeDir);
+    const sessionDir = path.join(storageBase, 'session');
+    const messageDir = path.join(storageBase, 'message');
+    const partDir = path.join(storageBase, 'part');
+    const sessionFile = await findSessionFile(sessionDir, sessionId);
+    if (!sessionFile) {
+        return { success: false, error: 'Session not found' };
+    }
+    let internalId = null;
+    try {
+        const content = await fs.readFile(sessionFile, 'utf-8');
+        const data = JSON.parse(content);
+        internalId = data.id;
+    }
+    catch {
+        // Continue with session file deletion only
+    }
+    try {
+        await fs.unlink(sessionFile);
+    }
+    catch (err) {
+        return { success: false, error: `Failed to delete session file: ${err}` };
+    }
+    if (internalId) {
+        const msgDir = path.join(messageDir, internalId);
+        try {
+            const msgFiles = await fs.readdir(msgDir);
+            for (const msgFile of msgFiles) {
+                if (!msgFile.startsWith('msg_') || !msgFile.endsWith('.json'))
+                    continue;
+                const msgPath = path.join(msgDir, msgFile);
+                try {
+                    const content = await fs.readFile(msgPath, 'utf-8');
+                    const msg = JSON.parse(content);
+                    if (msg.id) {
+                        const partMsgDir = path.join(partDir, msg.id);
+                        try {
+                            await fs.rm(partMsgDir, { recursive: true });
+                        }
+                        catch {
+                            // Parts may not exist
+                        }
+                    }
+                }
+                catch {
+                    // Skip malformed messages
+                }
+            }
+            await fs.rm(msgDir, { recursive: true });
+        }
+        catch {
+            // Messages directory may not exist
+        }
+    }
+    return { success: true };
+}

package/dist/sessions/agents/opencode.js CHANGED Viewed

@@ -1,6 +1,6 @@
 export const opencodeProvider = {
     async discoverSessions(containerName, exec) {
-        const result = await exec(containerName, ['perry-session-reader', 'list'], {
+        const result = await exec(containerName, ['perry', 'worker', 'sessions', 'list'], {
             user: 'workspace',
         });
         if (result.exitCode !== 0) {
@@ -22,7 +22,7 @@ export const opencodeProvider = {
         }
     },
     async getSessionDetails(containerName, rawSession, exec) {
-        const result = await exec(containerName, ['perry-session-reader', 'messages', rawSession.id], {
+        const result = await exec(containerName, ['perry', 'worker', 'sessions', 'messages', rawSession.id], {
             user: 'workspace',
         });
         if (result.exitCode !== 0) {
@@ -50,7 +50,7 @@ export const opencodeProvider = {
         }
     },
     async getSessionMessages(containerName, sessionId, exec) {
-        const result = await exec(containerName, ['perry-session-reader', 'messages', sessionId], {
+        const result = await exec(containerName, ['perry', 'worker', 'sessions', 'messages', sessionId], {
             user: 'workspace',
         });
         if (result.exitCode !== 0) {
@@ -67,4 +67,18 @@ export const opencodeProvider = {
             return null;
         }
     },
+    async deleteSession(containerName, sessionId, exec) {
+        const result = await exec(containerName, ['perry', 'worker', 'sessions', 'delete', sessionId], {
+            user: 'workspace',
+        });
+        if (result.exitCode !== 0) {
+            return { success: false, error: result.stderr || 'Failed to delete session' };
+        }
+        try {
+            return JSON.parse(result.stdout);
+        }
+        catch {
+            return { success: false, error: 'Invalid response from worker' };
+        }
+    },
 };

package/dist/sessions/cache.js CHANGED Viewed

@@ -49,4 +49,9 @@ export class SessionsCacheManager {
         cache.recent = cache.recent.filter((s) => s.workspaceName !== workspaceName);
         await this.save();
     }
+    async removeSession(workspaceName, sessionId) {
+        const cache = await this.load();
+        cache.recent = cache.recent.filter((s) => !(s.workspaceName === workspaceName && s.sessionId === sessionId));
+        await this.save();
+    }
 }

package/dist/shared/constants.js CHANGED Viewed

@@ -1,7 +1,7 @@
 export const DEFAULT_AGENT_PORT = 7391;
 export const SSH_PORT_RANGE_START = 2200;
 export const SSH_PORT_RANGE_END = 2400;
-export const WORKSPACE_IMAGE_LOCAL = 'workspace:latest';
+export const WORKSPACE_IMAGE_LOCAL = 'perry:latest';
 export const WORKSPACE_IMAGE_REGISTRY = 'ghcr.io/gricha/perry';
 export const VOLUME_PREFIX = 'workspace-';
 export const CONTAINER_PREFIX = 'workspace-';

package/dist/tailscale/index.js ADDED Viewed

@@ -0,0 +1,80 @@
+export async function getTailscaleStatus() {
+    try {
+        const proc = Bun.spawn(['tailscale', 'status', '--json'], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        const output = await new Response(proc.stdout).text();
+        const exitCode = await proc.exited;
+        if (exitCode !== 0) {
+            return { running: false, httpsEnabled: false };
+        }
+        const status = JSON.parse(output);
+        if (status.BackendState !== 'Running') {
+            return { running: false, httpsEnabled: false };
+        }
+        const dnsName = status.Self?.DNSName?.replace(/\.$/, '');
+        const tailnetName = dnsName?.split('.').slice(1).join('.');
+        const ipv4 = status.Self?.TailscaleIPs?.find((ip) => !ip.includes(':'));
+        const httpsEnabled = (status.CertDomains?.length ?? 0) > 0;
+        return {
+            running: true,
+            dnsName,
+            tailnetName,
+            ipv4,
+            httpsEnabled,
+        };
+    }
+    catch {
+        return { running: false, httpsEnabled: false };
+    }
+}
+export async function startTailscaleServe(port) {
+    try {
+        const proc = Bun.spawn(['tailscale', 'serve', '--bg', String(port)], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        const stderr = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+        if (exitCode === 0) {
+            return { success: true };
+        }
+        if (stderr.includes('Access denied') || stderr.includes('serve config denied')) {
+            return {
+                success: false,
+                error: 'permission_denied',
+                message: 'Run: sudo tailscale set --operator=$USER',
+            };
+        }
+        return { success: false, error: 'unknown', message: stderr.trim() };
+    }
+    catch (err) {
+        return { success: false, error: 'unknown', message: String(err) };
+    }
+}
+export async function stopTailscaleServe() {
+    try {
+        const proc = Bun.spawn(['tailscale', 'serve', 'off'], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        const exitCode = await proc.exited;
+        return exitCode === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function getTailscaleIdentity(req) {
+    const login = req.headers['tailscale-user-login'];
+    const name = req.headers['tailscale-user-name'];
+    const pic = req.headers['tailscale-user-profile-pic'];
+    if (!login)
+        return null;
+    return {
+        email: Array.isArray(login) ? login[0] : login,
+        name: Array.isArray(name) ? name[0] : name,
+        profilePic: Array.isArray(pic) ? pic[0] : pic,
+    };
+}

package/dist/workspace/manager.js CHANGED Viewed

@@ -282,10 +282,30 @@ export class WorkspaceManager {
         await this.setupClaudeCodeConfig(containerName);
         await this.copyCodexCredentials(containerName);
         await this.setupOpencodeConfig(containerName);
+        await this.copyPerryWorker(containerName);
         if (workspaceName) {
             await this.setupSSHKeys(containerName, workspaceName);
         }
     }
+    async copyPerryWorker(containerName) {
+        const distDir = path.dirname(new URL(import.meta.url).pathname);
+        const workerBinaryPath = path.join(distDir, '..', 'perry-worker');
+        try {
+            await fs.access(workerBinaryPath);
+        }
+        catch {
+            console.warn(`[sync] perry-worker binary not found at ${workerBinaryPath}, session discovery may not work`);
+            return;
+        }
+        const destPath = '/usr/local/bin/perry';
+        await docker.copyToContainer(containerName, workerBinaryPath, destPath);
+        await docker.execInContainer(containerName, ['chown', 'root:root', destPath], {
+            user: 'root',
+        });
+        await docker.execInContainer(containerName, ['chmod', '755', destPath], {
+            user: 'root',
+        });
+    }
     async runPostStartScript(containerName) {
         const scriptPath = this.config.scripts.post_start;
         if (!scriptPath) {
@@ -388,6 +408,10 @@ export class WorkspaceManager {
             if (clone) {
                 containerEnv.WORKSPACE_REPO_URL = clone;
             }
+            const dockerVolumeName = `${VOLUME_PREFIX}${name}-docker`;
+            if (!(await docker.volumeExists(dockerVolumeName))) {
+                await docker.createVolume(dockerVolumeName);
+            }
             const containerId = await docker.createContainer({
                 name: containerName,
                 image: workspaceImage,
@@ -395,7 +419,10 @@ export class WorkspaceManager {
                 privileged: true,
                 restartPolicy: 'unless-stopped',
                 env: containerEnv,
-                volumes: [{ source: volumeName, target: '/home/workspace', readonly: false }],
+                volumes: [
+                    { source: volumeName, target: '/home/workspace', readonly: false },
+                    { source: dockerVolumeName, target: '/var/lib/docker', readonly: false },
+                ],
                 ports: [{ hostPort: sshPort, containerPort: 22, protocol: 'tcp' }],
                 labels: {
                     'workspace.name': name,
@@ -451,6 +478,10 @@ export class WorkspaceManager {
                 if (workspace.repo) {
                     containerEnv.WORKSPACE_REPO_URL = workspace.repo;
                 }
+                const dockerVolumeName = `${VOLUME_PREFIX}${name}-docker`;
+                if (!(await docker.volumeExists(dockerVolumeName))) {
+                    await docker.createVolume(dockerVolumeName);
+                }
                 const containerId = await docker.createContainer({
                     name: containerName,
                     image: workspaceImage,
@@ -458,7 +489,10 @@ export class WorkspaceManager {
                     privileged: true,
                     restartPolicy: 'unless-stopped',
                     env: containerEnv,
-                    volumes: [{ source: volumeName, target: '/home/workspace', readonly: false }],
+                    volumes: [
+                        { source: volumeName, target: '/home/workspace', readonly: false },
+                        { source: dockerVolumeName, target: '/var/lib/docker', readonly: false },
+                    ],
                     ports: [{ hostPort: sshPort, containerPort: 22, protocol: 'tcp' }],
                     labels: {
                         'workspace.name': name,
@@ -515,12 +549,16 @@ export class WorkspaceManager {
         }
         const containerName = getContainerName(name);
         const volumeName = `${VOLUME_PREFIX}${name}`;
+        const dockerVolumeName = `${VOLUME_PREFIX}${name}-docker`;
         if (await docker.containerExists(containerName)) {
             await docker.removeContainer(containerName, true);
         }
         if (await docker.volumeExists(volumeName)) {
             await docker.removeVolume(volumeName, true);
         }
+        if (await docker.volumeExists(dockerVolumeName)) {
+            await docker.removeVolume(dockerVolumeName, true);
+        }
         await this.state.deleteWorkspace(name);
     }
     async exec(name, command) {