gestalt-mobile 0.20.0 → 0.21.0

package/dist/client/index.html

@@ -16,8 +16,8 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-Byfm-_gV.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DYERmevO.css">
+    <script type="module" crossorigin src="/assets/index-ufTniVfO.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D9-XA9jj.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/app.js

@@ -17,6 +17,7 @@ import { registerAuthorizationBoundary } from './platform/http/authorization-bou
 import { registerSkillRoutes } from './features/skills/register-routes.js';
 import { registerOrgPlanAttentionRoutes } from './features/org-plan-attention/register-routes.js';
 import { registerAutopilotRoutes } from './features/autopilot/register-routes.js';
+import { registerFileRoutes } from './features/files/register-routes.js';
 export async function buildApp(deps) {
     // Keep the default boundary finite even when an endpoint forgot a narrower schema.
     const app = fastify({ logger: false, bodyLimit: 1024 * 1024 });
@@ -48,6 +49,7 @@ export async function buildApp(deps) {
     if (deps.orgPlanAttention)
         registerOrgPlanAttentionRoutes(app, deps.orgPlanAttention);
     registerPlanRoutes(app, deps);
+    registerFileRoutes(app, deps);
     registerGitRoutes(app, deps);
     registerSkillRoutes(app, deps);
     registerProblemHandler(app, Boolean(deps.staticDir));

package/dist/server/server/composition.contracts.js

@@ -1512,6 +1512,42 @@ describe('production composition', () => {
                 ['GET', '/api/sessions/:id/plan', '/api/sessions/session-1/plan', 'protected'],
                 ['HEAD', '/api/sessions/:id/plan', '/api/sessions/session-1/plan', 'protected'],
                 ['DELETE', '/api/sessions/:id/plan', '/api/sessions/session-1/plan', 'protected'],
+                [
+                    'GET',
+                    '/api/workspaces/:workspaceId/files',
+                    '/api/workspaces/workspace-1/files',
+                    'protected',
+                ],
+                [
+                    'HEAD',
+                    '/api/workspaces/:workspaceId/files',
+                    '/api/workspaces/workspace-1/files',
+                    'protected',
+                ],
+                [
+                    'POST',
+                    '/api/workspaces/:workspaceId/files/copy',
+                    '/api/workspaces/workspace-1/files/copy',
+                    'protected',
+                ],
+                [
+                    'POST',
+                    '/api/workspaces/:workspaceId/files/move',
+                    '/api/workspaces/workspace-1/files/move',
+                    'protected',
+                ],
+                [
+                    'PUT',
+                    '/api/workspaces/:workspaceId/files/upload',
+                    '/api/workspaces/workspace-1/files/upload',
+                    'protected',
+                ],
+                [
+                    'DELETE',
+                    '/api/workspaces/:workspaceId/files',
+                    '/api/workspaces/workspace-1/files',
+                    'protected',
+                ],
                 [
                     'GET',
                     '/api/workspaces/:workspaceId/plans',

package/dist/server/server/composition.js

@@ -9,6 +9,7 @@ import { homedir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
 import { buildApp } from './app.js';
 import { FilesystemWorkspaceCatalog } from './platform/catalog/filesystem-workspace-catalog.js';
+import { FilesystemWorkspaceFiles } from './platform/filesystem/filesystem-workspace-files.js';
 import { protocolCompatibility } from './platform/codex/protocol-compatibility.js';
 import { launchCodexAppServer } from './platform/codex/codex-process-launcher.js';
 import { CodexModelCatalog } from './platform/codex/codex-model-catalog.js';
@@ -216,6 +217,7 @@ export async function composeRelayApp(options) {
     notifyAutopilotActivity = (sessionId) => autopilot.activityChanged(sessionId);
     options.onAutopilotCoordinator?.(autopilot);
     const workspaces = new FilesystemWorkspaceCatalog(root);
+    const workspaceFiles = new FilesystemWorkspaceFiles();
     const models = new CodexModelCatalog(root, options.launchAppServer ?? launchCodexAppServer);
     const skillProfiles = new FilesystemSkillProfileStore(options.homeDirectory ?? homedir());
     const skillCatalog = (profile) => new CodexSkillCatalog(profile, options.launchAppServer ?? launchCodexAppServer);
@@ -654,6 +656,7 @@ export async function composeRelayApp(options) {
                 },
             },
             workspacePlanRoutes: { workspaces, plans: workspacePlanCatalog },
+            workspaceFileRoutes: { workspaces, files: workspaceFiles },
             autopilot,
             ...(runtime
                 ? {

package/dist/server/server/features/files/application/ports.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export {};

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

@@ -0,0 +1,48 @@
+export function registerCopyEntry(app, deps) {
+    app.post('/api/workspaces/:workspaceId/files/copy', async (request, reply) => mutation(request, reply, deps, 'copy'));
+}
+export async function mutation(request, reply, deps, operation) {
+    const body = request.body;
+    if (!body ||
+        typeof body.source !== 'string' ||
+        typeof body.destinationDirectory !== 'string' ||
+        !['reject', 'replace', 'keep-both'].includes(body.conflict ?? ''))
+        return reply.code(400).send({ code: 'INVALID_FILE_MUTATION' });
+    const method = deps.files[operation];
+    if (!method)
+        return reply.code(503).send({ code: 'WORKSPACE_FILES_UNAVAILABLE' });
+    try {
+        const workspace = await deps.workspaces.resolve(request.params.workspaceId);
+        const result = await method.call(deps.files, workspace.realPath, body);
+        return map(reply, result);
+    }
+    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',
+        });
+    }
+}
+export function map(reply, result) {
+    if (result.kind === 'available')
+        return reply.send(result);
+    const mapped = {
+        missing: [404, 'FILE_NOT_FOUND'],
+        protected: [403, 'FILE_PROTECTED'],
+        symlink: [409, 'SYMLINK_UNSUPPORTED'],
+        'invalid-destination': [400, 'INVALID_FILE_DESTINATION'],
+        'source-inside-destination': [409, 'SOURCE_INSIDE_DESTINATION'],
+        'same-parent': [409, 'SAME_PARENT_MOVE'],
+        conflict: [409, 'FILE_CONFLICT'],
+        'replace-unsupported': [409, 'FILE_REPLACE_UNSUPPORTED'],
+        unreadable: [503, 'WORKSPACE_FILES_UNAVAILABLE'],
+    };
+    const [status, code] = mapped[result.kind] ?? [503, 'WORKSPACE_FILES_UNAVAILABLE'];
+    return reply.code(status).send({
+        code,
+        ...(result.kind === 'conflict' ? { replaceAllowed: result.replaceAllowed } : {}),
+    });
+}

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

@@ -0,0 +1,23 @@
+import { map } from '../copy-entry/endpoint.js';
+export function registerDeleteEntry(app, deps) {
+    app.delete('/api/workspaces/:workspaceId/files', async (request, reply) => {
+        const body = request.body;
+        if (typeof body?.path !== 'string' || body.recursive !== true)
+            return reply.code(400).send({ code: 'INVALID_DELETE_REQUEST' });
+        if (!deps.files.delete)
+            return reply.code(503).send({ code: 'WORKSPACE_FILES_UNAVAILABLE' });
+        try {
+            const w = await deps.workspaces.resolve(request.params.workspaceId);
+            return map(reply, await deps.files.delete(w.realPath, { path: body.path, recursive: true }));
+        }
+        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/files/domain/relative-directory.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function parseRelativeDirectory(value) {
+    if (value === '')
+        return value;
+    if (value.includes('\\') || value.includes('\0') || value.startsWith('/') || value.endsWith('/'))
+        return null;
+    const parts = value.split('/');
+    if (parts.some((part) => part === '' || part === '.' || part === '..' || part === '.git'))
+        return null;
+    return value;
+}

package/dist/server/server/features/files/domain/workspace-directory.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export {};

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',
+            });
+        }
+    });
+}