@gricha/perry 0.1.4 → 0.1.6

package/dist/update-checker.js

@@ -0,0 +1,81 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { mkdir, readFile, writeFile } from 'fs/promises';
+const PACKAGE_NAME = '@gricha/perry';
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+async function getCacheDir() {
+    const dir = join(homedir(), '.config', 'perry');
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+async function readCache() {
+    try {
+        const cacheFile = join(await getCacheDir(), 'update-cache.json');
+        const content = await readFile(cacheFile, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(cache) {
+    try {
+        const cacheFile = join(await getCacheDir(), 'update-cache.json');
+        await writeFile(cacheFile, JSON.stringify(cache));
+    }
+    catch {
+        // Ignore cache write errors
+    }
+}
+async function fetchLatestVersion() {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data.version || null;
+    }
+    catch {
+        return null;
+    }
+}
+function compareVersions(current, latest) {
+    const currentParts = current.split('.').map(Number);
+    const latestParts = latest.split('.').map(Number);
+    for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+        const c = currentParts[i] || 0;
+        const l = latestParts[i] || 0;
+        if (l > c)
+            return 1;
+        if (l < c)
+            return -1;
+    }
+    return 0;
+}
+export async function checkForUpdates(currentVersion) {
+    try {
+        const cache = await readCache();
+        const now = Date.now();
+        let latestVersion = null;
+        if (cache && now - cache.lastCheck < CHECK_INTERVAL_MS) {
+            latestVersion = cache.latestVersion;
+        }
+        else {
+            latestVersion = await fetchLatestVersion();
+            await writeCache({ lastCheck: now, latestVersion });
+        }
+        if (latestVersion && compareVersions(currentVersion, latestVersion) > 0) {
+            console.log('');
+            console.log(`\x1b[33m╭─────────────────────────────────────────────────────────╮\x1b[0m`);
+            console.log(`\x1b[33m│\x1b[0m  Update available: \x1b[90m${currentVersion}\x1b[0m → \x1b[32m${latestVersion}\x1b[0m                     \x1b[33m│\x1b[0m`);
+            console.log(`\x1b[33m│\x1b[0m  Run \x1b[36mnpm install -g ${PACKAGE_NAME}\x1b[0m to update   \x1b[33m│\x1b[0m`);
+            console.log(`\x1b[33m╰─────────────────────────────────────────────────────────╯\x1b[0m`);
+            console.log('');
+        }
+    }
+    catch {
+        // Silently ignore update check errors
+    }
+}

package/dist/workspace/manager.js

@@ -8,6 +8,7 @@ import { expandPath } from '../config/loader';
 import * as docker from '../docker';
 import { getContainerName } from '../docker';
 import { VOLUME_PREFIX, WORKSPACE_IMAGE_LOCAL, WORKSPACE_IMAGE_REGISTRY, SSH_PORT_RANGE_START, SSH_PORT_RANGE_END, } from '../shared/constants';
+import { collectAuthorizedKeys, collectCopyKeys } from '../ssh/sync';
 async function findAvailablePort(start, end) {
     for (let port = start; port <= end; port++) {
         const available = await new Promise((resolve) => {
@@ -226,12 +227,64 @@ export class WorkspaceManager {
             tempPrefix: 'ws-gitconfig',
         });
     }
-    async setupWorkspaceCredentials(containerName) {
+    async setupSSHKeys(containerName, workspaceName) {
+        if (!this.config.ssh) {
+            return;
+        }
+        await docker.execInContainer(containerName, ['mkdir', '-p', '/home/workspace/.ssh'], {
+            user: 'workspace',
+        });
+        await docker.execInContainer(containerName, ['chmod', '700', '/home/workspace/.ssh'], {
+            user: 'workspace',
+        });
+        const authorizedKeys = await collectAuthorizedKeys(this.config.ssh, workspaceName);
+        if (authorizedKeys.length > 0) {
+            const content = authorizedKeys.join('\n') + '\n';
+            const tempFile = path.join(os.tmpdir(), `ws-authkeys-${Date.now()}`);
+            try {
+                await fs.writeFile(tempFile, content);
+                await docker.copyToContainer(containerName, tempFile, '/home/workspace/.ssh/authorized_keys');
+                await docker.execInContainer(containerName, ['chown', 'workspace:workspace', '/home/workspace/.ssh/authorized_keys'], { user: 'root' });
+                await docker.execInContainer(containerName, ['chmod', '600', '/home/workspace/.ssh/authorized_keys'], { user: 'workspace' });
+            }
+            finally {
+                await fs.unlink(tempFile).catch(() => { });
+            }
+        }
+        const copyKeys = await collectCopyKeys(this.config.ssh, workspaceName);
+        for (const key of copyKeys) {
+            const privateKeyPath = `/home/workspace/.ssh/${key.name}`;
+            const publicKeyPath = `/home/workspace/.ssh/${key.name}.pub`;
+            const privateTempFile = path.join(os.tmpdir(), `ws-privkey-${Date.now()}`);
+            const publicTempFile = path.join(os.tmpdir(), `ws-pubkey-${Date.now()}`);
+            try {
+                await fs.writeFile(privateTempFile, key.privateKey + '\n');
+                await fs.writeFile(publicTempFile, key.publicKey + '\n');
+                await docker.copyToContainer(containerName, privateTempFile, privateKeyPath);
+                await docker.copyToContainer(containerName, publicTempFile, publicKeyPath);
+                await docker.execInContainer(containerName, ['chown', 'workspace:workspace', privateKeyPath, publicKeyPath], { user: 'root' });
+                await docker.execInContainer(containerName, ['chmod', '600', privateKeyPath], {
+                    user: 'workspace',
+                });
+                await docker.execInContainer(containerName, ['chmod', '644', publicKeyPath], {
+                    user: 'workspace',
+                });
+            }
+            finally {
+                await fs.unlink(privateTempFile).catch(() => { });
+                await fs.unlink(publicTempFile).catch(() => { });
+            }
+        }
+    }
+    async setupWorkspaceCredentials(containerName, workspaceName) {
         await this.copyGitConfig(containerName);
         await this.copyCredentialFiles(containerName);
         await this.setupClaudeCodeConfig(containerName);
         await this.copyCodexCredentials(containerName);
         await this.setupOpencodeConfig(containerName);
+        if (workspaceName) {
+            await this.setupSSHKeys(containerName, workspaceName);
+        }
     }
     async runPostStartScript(containerName) {
         const scriptPath = this.config.scripts.post_start;
@@ -347,7 +400,7 @@ export class WorkspaceManager {
             await this.state.setWorkspace(workspace);
             await docker.startContainer(containerName);
             await docker.waitForContainerReady(containerName);
-            await this.setupWorkspaceCredentials(containerName);
+            await this.setupWorkspaceCredentials(containerName, name);
             workspace.status = 'running';
             await this.state.setWorkspace(workspace);
             await this.runPostStartScript(containerName);
@@ -413,7 +466,7 @@ export class WorkspaceManager {
         }
         await docker.startContainer(containerName);
         await docker.waitForContainerReady(containerName);
-        await this.setupWorkspaceCredentials(containerName);
+        await this.setupWorkspaceCredentials(containerName, name);
         workspace.status = 'running';
         await this.state.setWorkspace(workspace);
         await this.runPostStartScript(containerName);
@@ -481,6 +534,6 @@ export class WorkspaceManager {
         if (!running) {
             throw new Error(`Workspace '${name}' is not running`);
         }
-        await this.setupWorkspaceCredentials(containerName);
+        await this.setupWorkspaceCredentials(containerName, name);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gricha/perry",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Self-contained CLI for spinning up Docker-in-Docker development environments with SSH and proxy helpers.",
   "type": "module",
   "bin": {