Tags for 128 and asm programs via bot

Author: stever

apps/gif-service/src/index.ts

@@ -2,6 +2,7 @@ import express from 'express';
 import tapeRoutes from './routes/tape.js';
 import basicRoutes from './routes/basic.js';
 import projectRoutes from './routes/project.js';
+import sourceRoutes from './routes/source.js';
 
 const app = express();
 const PORT = process.env.PORT || 5001;
@@ -11,6 +12,7 @@ app.use(express.text({ type: 'text/plain', limit: '256kb' }));
 app.use('/api', tapeRoutes);
 app.use('/api', basicRoutes);
 app.use('/api', projectRoutes);
+app.use('/api', sourceRoutes);
 
 app.get('/health', (req, res) => {
     res.json({ status: 'ok' });

apps/gif-service/src/routes/source.ts

@@ -0,0 +1,81 @@
+import { Router, Request, Response } from 'express';
+import { GIFGenerator } from '../gif-generator.js';
+import { compileProject } from '../compile.js';
+import { CompileError } from '../errors.js';
+
+const router = Router();
+
+type Format = 'gif' | 'mp4';
+
+function readSource(req: Request): { code: string; lang: string } | null {
+    if (typeof req.body === 'string') {
+        return req.body.trim() ? { code: req.body, lang: 'basic' } : null;
+    }
+    const body = req.body ?? {};
+    const code: unknown = body.code;
+    const lang: unknown = body.lang;
+    if (typeof code === 'string' && code.trim()) {
+        return { code, lang: typeof lang === 'string' && lang ? lang : 'basic' };
+    }
+    return null;
+}
+
+/**
+ * Compile inline source for a given language and render it. Generalises the
+ * BASIC route via compileProject, so the bot can render pasted assembly
+ * (lang=asm, pasmo) as well as BASIC. A compile failure responds 400 with the
+ * compiler messages.
+ */
+async function handle(format: Format, req: Request, res: Response): Promise<void> {
+    try {
+        const source = readSource(req);
+        if (!source) {
+            res.status(400).json({ error: 'No source provided' });
+            return;
+        }
+
+        const maxSeconds = parseInt(req.query.maxSeconds as string) || 30;
+        const staleThreshold = parseInt(req.query.staleThreshold as string) || 150;
+        const machineType = parseInt(req.query.machineType as string) || 48;
+        const scale = parseInt(req.query.scale as string) || (format === 'mp4' ? 4 : 2);
+
+        let tap: Buffer;
+        try {
+            tap = await compileProject(source.lang, source.code);
+        } catch (err) {
+            if (err instanceof CompileError) {
+                res.status(400).json({ error: 'Compilation failed', detail: err.message });
+                return;
+            }
+            throw err;
+        }
+
+        const generator = new GIFGenerator({
+            maxDurationMs: maxSeconds * 1000,
+            staleFrameThreshold: staleThreshold,
+            scale,
+        });
+        await generator.initialize();
+
+        console.log(
+            `Generating ${format.toUpperCase()} from ${source.code.length} bytes of ${source.lang}...`,
+        );
+        if (format === 'mp4') {
+            const mp4 = await generator.generateMp4FromTAP(tap, machineType);
+            res.setHeader('Content-Type', 'video/mp4');
+            res.send(mp4);
+        } else {
+            const gif = await generator.generateFromTAP(tap, machineType);
+            res.setHeader('Content-Type', 'image/gif');
+            res.send(gif);
+        }
+    } catch (error: any) {
+        console.error(`Error generating ${format} from source:`, error);
+        res.status(500).json({ error: error.message });
+    }
+}
+
+router.post('/source-to-gif', (req, res) => handle('gif', req, res));
+router.post('/source-to-mp4', (req, res) => handle('mp4', req, res));
+
+export default router;

apps/mastodon-bot/src/directives.ts

@@ -0,0 +1,39 @@
+// Hashtag directives a user can add to a toot to steer rendering.
+const MACHINE_TAGS: Record<string, number> = { '128': 128, '48': 48 };
+const LANG_TAGS: Record<string, string> = { asm: 'asm' };
+
+export interface Directives {
+    machineType?: number; // from #128 / #48
+    lang?: string; // from #asm
+    code: string; // source with recognised directive tags removed
+}
+
+/**
+ * Pull rendering directives out of plain-text toot content (the output of
+ * htmlToBasic) and return the remaining source.
+ *
+ * Only the exact recognised tags (#128, #48, #asm) are stripped; every other
+ * `#token` is left in place — Sinclair BASIC uses # for stream numbers
+ * (PRINT #2), so blanket stripping would corrupt valid programs.
+ */
+export function parseDirectives(text: string): Directives {
+    let machineType: number | undefined;
+    let lang: string | undefined;
+
+    const code = text
+        .replace(/(^|\s)#([A-Za-z0-9]+)\b/g, (whole, lead: string, tag: string) => {
+            const key = tag.toLowerCase();
+            if (key in MACHINE_TAGS) {
+                machineType = MACHINE_TAGS[key];
+                return lead;
+            }
+            if (key in LANG_TAGS) {
+                lang = LANG_TAGS[key];
+                return lead;
+            }
+            return whole; // unrecognised hashtag: leave untouched
+        })
+        .trim();
+
+    return { machineType, lang, code };
+}

apps/mastodon-bot/src/index.ts

@@ -1,7 +1,8 @@
 import { config, assertRuntimeConfig } from './config.js';
 import { htmlToBasic } from './basic.js';
 import { extractProjectRef } from './project.js';
-import { basicToMedia, projectToMedia } from './media.js';
+import { parseDirectives } from './directives.js';
+import { sourceToMedia, projectToMedia } from './media.js';
 import { loadState, saveState } from './state.js';
 import {
     MastodonAccount,
@@ -31,29 +32,42 @@ async function handleMention(self: MastodonAccount, n: MastodonNotification): Pr
     if (!status) return;
     if (status.account.id === self.id) return; // never answer ourselves
 
-    // A project link takes precedence over inline BASIC: the source already
+    // A project link takes precedence over inline source: the program already
     // lives on the site, so render it directly rather than parsing the toot.
+    // Directives (#128/#48 machine, #asm language) are read from the toot text
+    // in both cases; for a project link the URL's ?m= hint wins over a tag.
     const projectRef = extractProjectRef(status.content, config.projectHost);
-    const code = projectRef ? null : htmlToBasic(status.content);
+    const directives = parseDirectives(htmlToBasic(status.content));
+    const code = projectRef ? null : directives.code;
     if (!projectRef && !code) {
-        console.log(`Mention ${n.id} from @${status.account.acct}: no project link or BASIC found, skipping`);
+        console.log(`Mention ${n.id} from @${status.account.acct}: no project link or source found, skipping`);
         return;
     }
+
+    const machineType = projectRef ? (projectRef.machineType ?? directives.machineType) : directives.machineType;
+    const lang = directives.lang ?? 'basic';
     const projectPath = projectRef ? `${projectRef.userSlug}/${projectRef.projectSlug}` : '';
+    const machineNote = machineType ? ` @${machineType}K` : '';
     console.log(
         projectRef
-            ? `Mention ${n.id} from @${status.account.acct}: project ${projectPath}`
-            : `Mention ${n.id} from @${status.account.acct}: ${code!.split('\n').length} line(s)`,
+            ? `Mention ${n.id} from @${status.account.acct}: project ${projectPath}${machineNote}`
+            : `Mention ${n.id} from @${status.account.acct}: ${code!.split('\n').length} line(s) of ${lang}${machineNote}`,
     );
 
     const visibility = replyVisibility(status.visibility);
 
     if (config.dryRun) {
-        console.log(projectRef ? `[dry-run] would render project ${projectPath}` : `[dry-run] would run:\n${code}`);
+        console.log(
+            projectRef
+                ? `[dry-run] would render project ${projectPath}${machineNote}`
+                : `[dry-run] would run ${lang}${machineNote}:\n${code}`,
+        );
         return;
     }
 
-    const result = projectRef ? await projectToMedia(projectRef) : await basicToMedia(code!);
+    const result = projectRef
+        ? await projectToMedia(projectRef, machineType)
+        : await sourceToMedia(code!, lang, machineType);
 
     if (!result.ok) {
         await postReply({

apps/mastodon-bot/src/media.ts

@@ -6,9 +6,14 @@ export type MediaResult =
     | { ok: false; error: string };
 
 /** POST a render request to gif-service and shape the response into a MediaResult. */
-async function requestMedia(path: string, body: unknown, altText: string): Promise<MediaResult> {
-    const url = `${config.gifServiceUrl}${path}?maxSeconds=${config.maxSeconds}`;
-    const res = await fetch(url, {
+async function requestMedia(
+    path: string,
+    body: unknown,
+    altText: string,
+    params: Record<string, string> = {},
+): Promise<MediaResult> {
+    const query = new URLSearchParams({ maxSeconds: String(config.maxSeconds), ...params });
+    const res = await fetch(`${config.gifServiceUrl}${path}?${query}`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
@@ -34,16 +39,30 @@ async function requestMedia(path: string, body: unknown, altText: string): Promi
     return { ok: false, error: detail || `gif-service returned ${res.status}` };
 }
 
-/** Compile and run BASIC via gif-service, returning an MP4 or a user-facing error. */
+function machineParam(machineType?: number): Record<string, string> {
+    return machineType ? { machineType: String(machineType) } : {};
+}
+
+/** Compile and run inline source (BASIC or asm) via gif-service. */
+export function sourceToMedia(
+    code: string,
+    lang: string,
+    machineType?: number,
+): Promise<MediaResult> {
+    return requestMedia('/api/source-to-mp4', { code, lang }, code, machineParam(machineType));
+}
+
+/** Compile and run Sinclair BASIC via gif-service. */
 export function basicToMedia(code: string): Promise<MediaResult> {
-    return requestMedia('/api/basic-to-mp4', { code }, code);
+    return sourceToMedia(code, 'basic');
 }
 
-/** Render a public code.zxplay.org project via gif-service, returning an MP4 or an error. */
-export function projectToMedia(ref: ProjectRef): Promise<MediaResult> {
+/** Render a public code.zxplay.org project via gif-service. */
+export function projectToMedia(ref: ProjectRef, machineType?: number): Promise<MediaResult> {
     return requestMedia(
         '/api/project-to-mp4',
-        ref,
+        { userSlug: ref.userSlug, projectSlug: ref.projectSlug },
         `${config.projectHost}/u/${ref.userSlug}/${ref.projectSlug}`,
+        machineParam(machineType),
     );
 }

apps/mastodon-bot/src/project.ts

@@ -1,21 +1,25 @@
 export interface ProjectRef {
     userSlug: string;
     projectSlug: string;
+    machineType?: number; // from a ?m=128 / ?m=48 hint on the URL
 }
 
 const SLUG = '[a-z0-9-]+';
 
 /**
  * Find a code.zxplay.org project link in a status's HTML content and return its
  * user/project slugs. Matches the canonical URL, https://<host>/u/<user>/<project>,
- * whether it appears as an <a href> or as plain text. Returns null when there
- * is no such link.
+ * whether it appears as an <a href> or as plain text, and reads an optional
+ * ?m=128 / ?m=48 machine hint. Returns null when there is no such link.
  */
 export function extractProjectRef(content: string, host: string): ProjectRef | null {
     const escapedHost = host.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const re = new RegExp(`https?://${escapedHost}/u/(${SLUG})/(${SLUG})`, 'i');
+    const re = new RegExp(`https?://${escapedHost}/u/(${SLUG})/(${SLUG})(?:\\?m=(48|128))?`, 'i');
     const match = content.match(re);
-    return match
-        ? { userSlug: match[1].toLowerCase(), projectSlug: match[2].toLowerCase() }
-        : null;
+    if (!match) return null;
+    return {
+        userSlug: match[1].toLowerCase(),
+        projectSlug: match[2].toLowerCase(),
+        machineType: match[3] ? parseInt(match[3], 10) : undefined,
+    };
 }