npm - dot-studio - Versions diffs - 0.0.1 - Mend

dot-studio 0.0.1

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 (38) hide show

package/LICENSE +21 -0
package/README.md +214 -0
package/client/assets/index-C2eIILoa.css +41 -0
package/client/assets/index-DUPZ_Lw5.js +616 -0
package/client/assets/index.es-Btlrnc3g.js +1 -0
package/client/index.html +14 -0
package/dist/cli.js +196 -0
package/dist/server/index.js +79 -0
package/dist/server/lib/act-runtime.js +1282 -0
package/dist/server/lib/cache.js +31 -0
package/dist/server/lib/config.js +53 -0
package/dist/server/lib/dot-authoring.js +245 -0
package/dist/server/lib/dot-loader.js +61 -0
package/dist/server/lib/dot-login.js +190 -0
package/dist/server/lib/model-catalog.js +111 -0
package/dist/server/lib/opencode-auth.js +69 -0
package/dist/server/lib/opencode-errors.js +220 -0
package/dist/server/lib/opencode-sidecar.js +144 -0
package/dist/server/lib/opencode.js +12 -0
package/dist/server/lib/package-bin.js +63 -0
package/dist/server/lib/project-config.js +39 -0
package/dist/server/lib/prompt.js +222 -0
package/dist/server/lib/request-context.js +27 -0
package/dist/server/lib/runtime-tools.js +208 -0
package/dist/server/routes/assets.js +161 -0
package/dist/server/routes/chat.js +356 -0
package/dist/server/routes/compile.js +105 -0
package/dist/server/routes/dot.js +270 -0
package/dist/server/routes/health.js +56 -0
package/dist/server/routes/opencode.js +421 -0
package/dist/server/routes/stages.js +137 -0
package/dist/server/start.js +23 -0
package/dist/server/terminal.js +282 -0
package/dist/shared/mcp-config.js +19 -0
package/dist/shared/model-variants.js +50 -0
package/dist/shared/project-mcp.js +22 -0
package/dist/shared/session-metadata.js +26 -0
package/package.json +103 -0

package/client/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>DOT Studio</title>
+    <script type="module" crossorigin src="/assets/index-DUPZ_Lw5.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C2eIILoa.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+// DOT Studio CLI — npx dot-studio [projectDir] [--no-open]
+import fs from 'fs/promises';
+import { resolve, basename, dirname, join } from 'path';
+import net from 'net';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import readline from 'readline/promises';
+function parseCliArgs(argv) {
+    let openBrowser = true;
+    let projectDir = null;
+    let port = null;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--no-open') {
+            openBrowser = false;
+            continue;
+        }
+        if (arg === '--open') {
+            openBrowser = true;
+            continue;
+        }
+        if (arg === '--port' || arg === '-p') {
+            const value = argv[index + 1];
+            if (!value) {
+                console.error(`Missing value for ${arg}`);
+                process.exit(1);
+            }
+            const parsed = Number.parseInt(value, 10);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                console.error(`Invalid port: ${value}`);
+                process.exit(1);
+            }
+            port = parsed;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            console.error(`Unknown option: ${arg}`);
+            process.exit(1);
+        }
+        if (projectDir) {
+            console.error(`Unexpected extra argument: ${arg}`);
+            process.exit(1);
+        }
+        projectDir = arg;
+    }
+    return {
+        openBrowser,
+        projectDir: resolve(projectDir || process.cwd()),
+        port,
+    };
+}
+function canListenOnPort(port) {
+    return new Promise((resolvePromise) => {
+        const server = net.createServer();
+        server.once('error', () => {
+            resolvePromise(false);
+        });
+        server.once('listening', () => {
+            server.close(() => resolvePromise(true));
+        });
+        server.listen({
+            port,
+            host: '::',
+            exclusive: true,
+        });
+    });
+}
+function compareSemver(left, right) {
+    const normalize = (value) => value
+        .split('-')[0]
+        .split('.')
+        .map((part) => Number.parseInt(part, 10) || 0);
+    const leftParts = normalize(left);
+    const rightParts = normalize(right);
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = leftParts[index] || 0;
+        const rightValue = rightParts[index] || 0;
+        if (leftValue === rightValue) {
+            continue;
+        }
+        return leftValue - rightValue;
+    }
+    return 0;
+}
+async function readStudioPackageMeta() {
+    const currentFile = fileURLToPath(import.meta.url);
+    const currentDir = dirname(currentFile);
+    const packageRoot = basename(currentDir) === 'dist' ? dirname(currentDir) : currentDir;
+    const raw = await fs.readFile(join(packageRoot, 'package.json'), 'utf-8');
+    return JSON.parse(raw);
+}
+async function fetchLatestVersion(packageName) {
+    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`, {
+        headers: {
+            accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch npm metadata for ${packageName}.`);
+    }
+    const payload = await response.json();
+    return payload.version || null;
+}
+async function promptForNpmUpdate(packageMeta) {
+    let latestVersion = null;
+    try {
+        latestVersion = await fetchLatestVersion(packageMeta.name);
+    }
+    catch {
+        return false;
+    }
+    if (!latestVersion || compareSemver(latestVersion, packageMeta.version) <= 0) {
+        return false;
+    }
+    const message = `A newer ${packageMeta.name} version is available on npm (${packageMeta.version} -> ${latestVersion}). Update now? [Y/n] `;
+    const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    if (!isInteractive) {
+        console.log(`${message.trim()} Run npm install -g ${packageMeta.name}@latest to update.`);
+        return false;
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = (await rl.question(message)).trim().toLowerCase();
+        if (answer && answer !== 'y' && answer !== 'yes') {
+            return false;
+        }
+    }
+    finally {
+        rl.close();
+    }
+    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn(npmCommand, ['install', '-g', `${packageMeta.name}@latest`], {
+            stdio: 'inherit',
+        });
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolvePromise();
+                return;
+            }
+            reject(new Error(`npm install exited with code ${code ?? 1}.`));
+        });
+        child.on('error', reject);
+    });
+    console.log(`Updated ${packageMeta.name} to ${latestVersion}. Run dot-studio again to start the new version.`);
+    return true;
+}
+const startServer = async () => {
+    try {
+        const packageMeta = await readStudioPackageMeta();
+        const updated = await promptForNpmUpdate(packageMeta);
+        if (updated) {
+            process.exit(0);
+        }
+        const { openBrowser, projectDir, port: requestedPort } = parseCliArgs(process.argv.slice(2));
+        const basePort = requestedPort || Number.parseInt(process.env.PORT || '3001', 10) || 3001;
+        let resolvedPort = basePort;
+        if (requestedPort) {
+            if (!(await canListenOnPort(requestedPort))) {
+                console.error(`Port ${requestedPort} is already in use.`);
+                process.exit(1);
+            }
+        }
+        else {
+            while (!(await canListenOnPort(resolvedPort))) {
+                resolvedPort += 1;
+                if (resolvedPort - basePort > 20) {
+                    console.error(`Could not find an open port starting from ${basePort}.`);
+                    process.exit(1);
+                }
+            }
+        }
+        process.env.PROJECT_DIR = projectDir;
+        process.env.DOT_STUDIO_PRODUCTION = '1';
+        process.env.PORT = String(resolvedPort);
+        const studioUrl = `http://localhost:${resolvedPort}`;
+        // Dynamic import to let env vars take effect before config.ts loads
+        await import('./server/index.js');
+        console.log(`DOT Studio running at ${studioUrl}`);
+        if (openBrowser) {
+            const open = await import('open');
+            await open.default(studioUrl);
+        }
+    }
+    catch (err) {
+        console.error('Failed to start DOT Studio:', err);
+        process.exit(1);
+    }
+};
+startServer();

package/dist/server/index.js ADDED Viewed

@@ -0,0 +1,79 @@
+// DOT Studio — Hono API Server (Entry Point)
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { setupTerminalWs } from './terminal.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+// Route Modules
+import healthRoutes from './routes/health.js';
+import assetRoutes from './routes/assets.js';
+import stageRoutes from './routes/stages.js';
+import chatRoutes from './routes/chat.js';
+import opencodeRoutes from './routes/opencode.js';
+import compileRoutes from './routes/compile.js';
+import dotRoutes from './routes/dot.js';
+// Config
+import { PORT, OPENCODE_URL, STUDIO_DIR, IS_PRODUCTION, getActiveProjectDir } from './lib/config.js';
+import { ensureOpencodeSidecar, isManagedOpencode } from './lib/opencode-sidecar.js';
+const app = new Hono();
+function resolveClientDir() {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(__dirname, '..', '..', 'client'),
+        path.resolve(__dirname, '..', 'client'),
+    ];
+    return candidates.find((dir) => fs.existsSync(path.join(dir, 'index.html'))) || candidates[0];
+}
+if (IS_PRODUCTION) {
+    // Production: Hono serves built frontend from client/ directory
+    const clientDir = resolveClientDir();
+    // API routes first, then static files
+    app.route('/', healthRoutes);
+    app.route('/', assetRoutes);
+    app.route('/', stageRoutes);
+    app.route('/', chatRoutes);
+    app.route('/', opencodeRoutes);
+    app.route('/', compileRoutes);
+    app.route('/', dotRoutes);
+    // Serve static assets
+    app.use('/assets/*', serveStatic({ root: clientDir }));
+    // SPA fallback: serve index.html for all non-API, non-asset routes
+    app.get('*', async (c) => {
+        const indexPath = path.join(clientDir, 'index.html');
+        if (fs.existsSync(indexPath)) {
+            const html = fs.readFileSync(indexPath, 'utf-8');
+            return c.html(html);
+        }
+        return c.text('Not found', 404);
+    });
+}
+else {
+    // Dev: allow localhost Vite ports so API calls keep working when Vite auto-increments.
+    app.use('*', cors({
+        origin: (origin) => (/^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)
+            ? origin
+            : null),
+    }));
+    // ── Mount Route Modules ─────────────────────────────────
+    app.route('/', healthRoutes);
+    app.route('/', assetRoutes);
+    app.route('/', stageRoutes);
+    app.route('/', chatRoutes);
+    app.route('/', opencodeRoutes);
+    app.route('/', compileRoutes);
+    app.route('/', dotRoutes);
+}
+// ── Start Server ────────────────────────────────────────
+await ensureOpencodeSidecar().catch((err) => {
+    console.warn(`OpenCode sidecar is not ready yet: ${err instanceof Error ? err.message : String(err)}`);
+});
+console.log(`\n🎪 DOT Studio Server${IS_PRODUCTION ? ' (production)' : ' (dev)'}`);
+console.log(`   API:      http://localhost:${PORT}`);
+console.log(`   OpenCode: ${OPENCODE_URL} (${isManagedOpencode() ? 'managed sidecar' : 'external'})`);
+console.log(`   Project:  ${getActiveProjectDir()}`);
+console.log(`   Data:     ${STUDIO_DIR}\n`);
+const server = serve({ fetch: app.fetch, port: PORT });
+setupTerminalWs(server, () => getActiveProjectDir());