@gricha/perry 0.1.5 → 0.1.7

package/dist/agent/router.js

@@ -7,6 +7,7 @@ import { HOST_WORKSPACE_NAME } from '../shared/types';
 import { getDockerVersion, execInContainer } from '../docker';
 import { saveAgentConfig } from '../config/loader';
 import { setSessionName, getSessionNamesForWorkspace, deleteSessionName, } from '../sessions/metadata';
+import { discoverSSHKeys } from '../ssh/discovery';
 import { parseClaudeSessionContent } from '../sessions/parser';
 import { discoverAllSessions, getSessionDetails as getAgentSessionDetails, getSessionMessages, findSessionMessages, } from '../sessions/agents';
 const WorkspaceStatusSchema = z.enum(['running', 'stopped', 'creating', 'error']);
@@ -21,6 +22,7 @@ const WorkspaceInfoSchema = z.object({
     created: z.string(),
     repo: z.string().optional(),
     ports: WorkspacePortsSchema,
+    lastUsed: z.string().optional(),
 });
 const CredentialsSchema = z.object({
     env: z.record(z.string(), z.string()),
@@ -47,6 +49,23 @@ const CodingAgentsSchema = z.object({
     })
         .optional(),
 });
+const SSHKeyConfigSchema = z.object({
+    copy: z.array(z.string()),
+    authorize: z.array(z.string()),
+});
+const SSHSettingsSchema = z.object({
+    autoAuthorizeHostKeys: z.boolean(),
+    global: SSHKeyConfigSchema,
+    workspaces: z.record(z.string(), SSHKeyConfigSchema.partial()),
+});
+const SSHKeyInfoSchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    publicKeyPath: z.string(),
+    type: z.enum(['ed25519', 'rsa', 'ecdsa', 'dsa', 'unknown']),
+    fingerprint: z.string(),
+    hasPrivateKey: z.boolean(),
+});
 function mapErrorToORPC(err, defaultMessage) {
     const message = err instanceof Error ? err.message : defaultMessage;
     if (message.includes('not found')) {
@@ -154,6 +173,16 @@ export function createRouter(ctx) {
             results,
         };
     });
+    const touchWorkspace = os
+        .input(z.object({ name: z.string() }))
+        .output(WorkspaceInfoSchema)
+        .handler(async ({ input }) => {
+        const workspace = await ctx.workspaces.touch(input.name);
+        if (!workspace) {
+            throw new ORPCError('NOT_FOUND', { message: 'Workspace not found' });
+        }
+        return workspace;
+    });
     const getInfo = os.handler(async () => {
         let dockerVersion = 'unknown';
         try {
@@ -210,6 +239,27 @@ export function createRouter(ctx) {
         await saveAgentConfig(newConfig, ctx.configDir);
         return input;
     });
+    const getSSHSettings = os.output(SSHSettingsSchema).handler(async () => {
+        const config = ctx.config.get();
+        return (config.ssh || {
+            autoAuthorizeHostKeys: true,
+            global: { copy: [], authorize: [] },
+            workspaces: {},
+        });
+    });
+    const updateSSHSettings = os
+        .input(SSHSettingsSchema)
+        .output(SSHSettingsSchema)
+        .handler(async ({ input }) => {
+        const currentConfig = ctx.config.get();
+        const newConfig = { ...currentConfig, ssh: input };
+        ctx.config.set(newConfig);
+        await saveAgentConfig(newConfig, ctx.configDir);
+        return input;
+    });
+    const listSSHKeys = os.output(z.array(SSHKeyInfoSchema)).handler(async () => {
+        return discoverSSHKeys();
+    });
     async function listHostSessions(input) {
         const limit = input.limit ?? 50;
         const offset = input.offset ?? 0;
@@ -550,42 +600,23 @@ export function createRouter(ctx) {
         await deleteSessionName(ctx.stateDir, input.workspaceName, input.sessionId);
         return { success: true };
     });
-    const listAllSessions = os
+    const getRecentSessions = os
         .input(z.object({
-        agentType: z.enum(['claude-code', 'opencode', 'codex']).optional(),
-        limit: z.number().optional().default(100),
-        offset: z.number().optional().default(0),
+        limit: z.number().optional().default(10),
     }))
         .handler(async ({ input }) => {
-        const allWorkspaces = await ctx.workspaces.list();
-        const runningWorkspaces = allWorkspaces.filter((w) => w.status === 'running');
-        const allSessions = [];
-        for (const workspace of runningWorkspaces) {
-            try {
-                const result = await listSessionsCore({
-                    workspaceName: workspace.name,
-                    agentType: input.agentType,
-                    limit: 1000,
-                    offset: 0,
-                });
-                for (const session of result.sessions) {
-                    allSessions.push({
-                        ...session,
-                        workspaceName: workspace.name,
-                    });
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-        allSessions.sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
-        const paginatedSessions = allSessions.slice(input.offset, input.offset + input.limit);
-        return {
-            sessions: paginatedSessions,
-            total: allSessions.length,
-            hasMore: input.offset + input.limit < allSessions.length,
-        };
+        const recent = await ctx.sessionsCache.getRecent(input.limit);
+        return { sessions: recent };
+    });
+    const recordSessionAccess = os
+        .input(z.object({
+        workspaceName: z.string(),
+        sessionId: z.string(),
+        agentType: z.enum(['claude-code', 'opencode', 'codex']),
+    }))
+        .handler(async ({ input }) => {
+        await ctx.sessionsCache.recordAccess(input.workspaceName, input.sessionId, input.agentType);
+        return { success: true };
     });
     const getHostInfo = os.handler(async () => {
         const config = ctx.config.get();
@@ -621,13 +652,15 @@ export function createRouter(ctx) {
             logs: getLogs,
             sync: syncWorkspace,
             syncAll: syncAllWorkspaces,
+            touch: touchWorkspace,
         },
         sessions: {
             list: listSessions,
-            listAll: listAllSessions,
             get: getSession,
             rename: renameSession,
             clearName: clearSessionName,
+            getRecent: getRecentSessions,
+            recordAccess: recordSessionAccess,
         },
         host: {
             info: getHostInfo,
@@ -647,6 +680,11 @@ export function createRouter(ctx) {
                 get: getAgents,
                 update: updateAgents,
             },
+            ssh: {
+                get: getSSHSettings,
+                update: updateSSHSettings,
+                listKeys: listSSHKeys,
+            },
         },
     };
 }

package/dist/agent/run.js

@@ -10,6 +10,7 @@ import { ChatWebSocketServer } from '../chat/websocket';
 import { OpencodeWebSocketServer } from '../chat/opencode-websocket';
 import { createRouter } from './router';
 import { serveStatic } from './static';
+import { SessionsCacheManager } from '../sessions/cache';
 import pkg from '../../package.json';
 const startTime = Date.now();
 function sendJson(res, status, data) {
@@ -19,6 +20,7 @@ function sendJson(res, status, data) {
 function createAgentServer(configDir, config) {
     let currentConfig = config;
     const workspaces = new WorkspaceManager(configDir, currentConfig);
+    const sessionsCache = new SessionsCacheManager(configDir);
     const isWorkspaceRunning = async (name) => {
         if (name === HOST_WORKSPACE_NAME) {
             return currentConfig.allowHostAccess === true;
@@ -52,6 +54,7 @@ function createAgentServer(configDir, config) {
         stateDir: configDir,
         startTime,
         terminalServer,
+        sessionsCache,
     });
     const rpcHandler = new RPCHandler(router);
     const server = createServer(async (req, res) => {