gestalt-mobile 0.20.1 → 0.22.0

package/dist/server/server/features/files/list-directory/endpoint.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { parseRelativeDirectory } from '../domain/relative-directory.js';
+const defaultLimit = 250;
+const maximumLimit = 500;
+export function registerListDirectory(app, deps) {
+    app.get('/api/workspaces/:workspaceId/files', async (request, reply) => {
+        const query = request.query;
+        const directoryRaw = query.directory === undefined ? '' : query.directory;
+        const directory = typeof directoryRaw === 'string' ? parseRelativeDirectory(directoryRaw) : null;
+        const cursor = query.cursor === undefined ? undefined : query.cursor;
+        const limit = parseLimit(query.limit);
+        if (directory === null ||
+            (cursor !== undefined && (typeof cursor !== 'string' || cursor === '')) ||
+            !limit)
+            return reply.code(400).send({ code: 'INVALID_DIRECTORY_REQUEST' });
+        try {
+            const workspace = await deps.workspaces.resolve(request.params.workspaceId);
+            const result = await deps.files.list(workspace.realPath, { directory, cursor, limit });
+            if (result.kind === 'available')
+                return reply.send(result.page);
+            const mapped = {
+                missing: [404, 'DIRECTORY_NOT_FOUND'],
+                'not-directory': [409, 'DIRECTORY_NOT_DIRECTORY'],
+                unreadable: [403, 'DIRECTORY_UNREADABLE'],
+                'invalid-cursor': [400, 'INVALID_DIRECTORY_CURSOR'],
+                'stale-cursor': [409, 'STALE_DIRECTORY_CURSOR'],
+            };
+            const [status, code] = mapped[result.kind];
+            return reply.code(status).send({ code });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND')
+                return reply.code(404).send({ code: 'WORKSPACE_NOT_FOUND' });
+            return reply.code(503).send({ code: 'WORKSPACE_FILES_UNAVAILABLE' });
+        }
+    });
+}
+function parseLimit(value) {
+    if (value === undefined)
+        return defaultLimit;
+    if (typeof value !== 'string' || !/^(?:[1-9]\d*)$/.test(value))
+        return null;
+    const parsed = Number(value);
+    return parsed <= maximumLimit ? parsed : null;
+}

package/dist/server/server/features/files/move-entry/endpoint.js

@@ -0,0 +1,4 @@
+import { mutation } from '../copy-entry/endpoint.js';
+export function registerMoveEntry(app, deps) {
+    app.post('/api/workspaces/:workspaceId/files/move', async (request, reply) => mutation(request, reply, deps, 'move'));
+}

package/dist/server/server/features/files/register-routes.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { registerListDirectory } from './list-directory/endpoint.js';
+import { registerCopyEntry } from './copy-entry/endpoint.js';
+import { registerMoveEntry } from './move-entry/endpoint.js';
+import { registerUploadFile } from './upload-file/endpoint.js';
+import { registerDeleteEntry } from './delete-entry/endpoint.js';
+export function registerFileRoutes(app, deps) {
+    if (!deps.workspaceFileRoutes)
+        return;
+    registerListDirectory(app, deps.workspaceFileRoutes);
+    registerCopyEntry(app, deps.workspaceFileRoutes);
+    registerMoveEntry(app, deps.workspaceFileRoutes);
+    registerUploadFile(app, deps.workspaceFileRoutes);
+    registerDeleteEntry(app, deps.workspaceFileRoutes);
+}

package/dist/server/server/features/files/upload-file/endpoint.js

@@ -0,0 +1,35 @@
+import { map } from '../copy-entry/endpoint.js';
+export function registerUploadFile(app, deps) {
+    app.addContentTypeParser('application/octet-stream', { parseAs: 'buffer' }, (_request, body, done) => done(null, body));
+    app.put('/api/workspaces/:workspaceId/files/upload', { bodyLimit: 25 * 1024 * 1024 }, async (request, reply) => {
+        const q = request.query;
+        const conflict = q.conflict;
+        if (typeof q.directory !== 'string' ||
+            typeof q.filename !== 'string' ||
+            !['reject', 'replace', 'keep-both'].includes(String(conflict)))
+            return reply.code(400).send({ code: 'INVALID_UPLOAD_REQUEST' });
+        if (!deps.files.upload)
+            return reply.code(503).send({ code: 'WORKSPACE_FILES_UNAVAILABLE' });
+        try {
+            const workspace = await deps.workspaces.resolve(request.params.workspaceId);
+            if (!Buffer.isBuffer(request.body))
+                return reply.code(415).send({ code: 'INVALID_UPLOAD_CONTENT' });
+            const content = request.body;
+            return map(reply, await deps.files.upload(workspace.realPath, {
+                directory: q.directory,
+                filename: q.filename,
+                conflict: conflict,
+                content,
+            }));
+        }
+        catch (error) {
+            return reply
+                .code(error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND' ? 404 : 503)
+                .send({
+                code: error instanceof Error && error.message === 'WORKSPACE_NOT_FOUND'
+                    ? 'WORKSPACE_NOT_FOUND'
+                    : 'WORKSPACE_FILES_UNAVAILABLE',
+            });
+        }
+    });
+}

package/dist/server/server/features/sessions/list-sessions/endpoint.js

@@ -5,10 +5,14 @@
  */
 import { buildResumeCommand } from '../application/resume-command.js';
 export function registerListSessions(app, deps) {
-    app.get('/api/sessions', async () => deps.list().map((session) => ({
-        ...session,
-        ...(deps.activity ? { agentActivity: deps.activity(session.id) } : {}),
-        ...(deps.autopilot ? { autopilot: deps.autopilot(session.id) } : {}),
-        resumeCommand: session.threadId ? buildResumeCommand(session) : null,
-    })));
+    app.get('/api/sessions', async () => deps.list().map((session) => {
+        const plan = deps.plan?.(session.id) ?? null;
+        return {
+            ...session,
+            ...(deps.activity ? { agentActivity: deps.activity(session.id) } : {}),
+            ...(deps.autopilot ? { autopilot: deps.autopilot(session.id) } : {}),
+            ...(plan ? { plan } : {}),
+            resumeCommand: session.threadId ? buildResumeCommand(session) : null,
+        };
+    }));
 }

package/dist/server/server/features/sessions/model/relay-session.js

@@ -14,6 +14,21 @@ export function isSessionReadable(session) {
 export function relayOwnsWriter(session) {
     return session.state === 'ready' || session.state === 'turnActive';
 }
+const sandboxes = new Set(['read-only', 'workspace-write', 'danger-full-access']);
+const approvalPolicies = new Set(['untrusted', 'on-request', 'never']);
+export function createSessionExecutionPolicy(input) {
+    if (input.sandbox !== undefined &&
+        (typeof input.sandbox !== 'string' || !sandboxes.has(input.sandbox)))
+        throw new DomainError('SESSION_EXECUTION_POLICY_INVALID');
+    const approvalPolicy = input.approvalPolicy ?? 'on-request';
+    if (typeof approvalPolicy !== 'string' ||
+        !approvalPolicies.has(approvalPolicy))
+        throw new DomainError('SESSION_EXECUTION_POLICY_INVALID');
+    return {
+        ...(input.sandbox === undefined ? {} : { sandbox: input.sandbox }),
+        approvalPolicy: approvalPolicy,
+    };
+}
 export function createEffectiveSkillSelection(input) {
     return {
         ...(input.selectedProfileName === undefined
@@ -38,6 +53,7 @@ export class RelaySession {
             ...(input.model === undefined ? {} : { model: input.model }),
             ...(input.branch === undefined ? {} : { branch: input.branch }),
             effectiveSkillSelection: createEffectiveSkillSelection(input.effectiveSkillSelection),
+            executionPolicy: createSessionExecutionPolicy(input),
             threadId: null,
             state: 'starting',
             desiredState: 'active',
@@ -55,6 +71,9 @@ export class RelaySession {
             workspaceId: workspaceId(input.workspaceId),
             workspacePath: workspacePath(input.workspacePath),
             profile: profileName(input.profile),
+            ...(input.executionPolicy === undefined
+                ? {}
+                : { executionPolicy: createSessionExecutionPolicy(input.executionPolicy) }),
             threadId: threadId(input.threadId),
             state: 'stopped',
             desiredState: 'stopped',

package/dist/server/server/features/sessions/promote-recent-thread/use-case.js

@@ -3,7 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-import { RelaySession } from '../model/relay-session.js';
+import { RelaySession, } from '../model/relay-session.js';
 export class RecentThreadHistoryUnavailable extends Error {
     constructor() {
         super('RECENT_THREAD_HISTORY_UNAVAILABLE');
@@ -28,15 +28,24 @@ export async function promoteRecentThread(thread, deps) {
 async function promote(thread, deps) {
     const existing = deps.list().find((session) => session.threadId === thread.id);
     if (existing) {
+        const executionPolicy = existing.executionPolicy
+            ? undefined
+            : await deps.executionPolicy?.(thread);
+        const recovered = executionPolicy
+            ? { ...existing, executionPolicy, updatedAt: deps.now() }
+            : existing;
         try {
-            await deps.read(existing);
+            await deps.read(recovered);
         }
         catch {
             throw new RecentThreadHistoryUnavailable();
         }
-        return existing;
+        if (recovered !== existing)
+            deps.save(recovered);
+        return recovered;
     }
     const now = deps.now();
+    const executionPolicy = await deps.executionPolicy?.(thread);
     const imported = existing ??
         RelaySession.fromExistingThread({
             id: deps.createId(),
@@ -44,6 +53,7 @@ async function promote(thread, deps) {
             workspacePath: thread.cwd,
             profile: thread.profile,
             threadId: thread.id,
+            ...(executionPolicy === undefined ? {} : { executionPolicy }),
             now,
         }).snapshot;
     // Validate first: an unavailable thread must never leave an imported stub.

package/dist/server/server/features/sessions/register-routes.js

@@ -59,6 +59,7 @@ export function registerSessionRoutes(app, deps) {
                 list: sessions.list,
                 activity: sessions.agentActivity,
                 autopilot: sessions.autopilotSnapshot,
+                plan: sessions.plan,
             });
         if (sessions.readHistory)
             registerGetHistory(app, {

package/dist/server/server/features/sessions/start-session/use-case.js

@@ -44,17 +44,15 @@ export async function startSession(input, deps) {
         profile: input.profile,
         model,
         ...(branch ? { branch } : {}),
+        sandbox: input.sandbox,
+        approvalPolicy: input.approvalPolicy,
         effectiveSkillSelection,
         now: deps.now(),
     }).snapshot;
     deps.save(session);
     if (!deps.activate)
         return session;
-    const active = await deps.activate(session, {
-        model,
-        sandbox: input.sandbox,
-        approvalPolicy: input.approvalPolicy,
-    });
+    const active = await deps.activate(session, {});
     deps.save(active);
     return active;
 }