Update index.js

index.js

@@ -61,8 +61,9 @@ function checkTools() {
 }
 
 // ── CHARACTER FILE HELPERS ────────────────────────────────────────────────────
-// characters.txt is one line: records separated by `3`, fields by `|`
-// We never send the raw blob to the frontend — all edits happen server-side.
+// characters.txt is a single line of pipe-delimited fields.
+// Character boundaries are detected by the pattern: name | alias | number
+// (same logic as the frontend parseCharacters function).
 
 function sessionDir(token) {
   return token === 'persistent'
@@ -81,19 +82,63 @@ function readChars(token) {
   return fs.readFileSync(p, 'utf8');
 }
 
-// Write back to disk — never goes through the browser
+// Write back to disk — raw flat pipe-delimited string, no newlines added
 function writeChars(token, raw) {
   fs.writeFileSync(charsPath(token), raw, 'utf8');
 }
 
-// Parse raw string into array of field arrays
+// Mirror of the HTML's parseCharacters():
+// Splits on '|', detects boundaries where: allFields[i-1]=name, allFields[i]=alias, allFields[i+1]=number
+// Returns array of: { index, name, alias, fields, startIdx }
+//   - name:     allFields[start - 1]  (the token just before the boundary)
+//   - alias:    fields[0]             (first field inside the boundary = allFields[start])
+//   - fields:   allFields[start .. next_boundary-2]  (the character's own pipe segment)
+//   - startIdx: index into allFields where this character's fields begin
 function parseChars(raw) {
-  return raw.split('3').map(r => r.split('|'));
+  const allFields = raw.split('|');
+
+  function isNameToken(s) {
+    s = s.trim();
+    return s.length > 1 && /[A-Za-z]/.test(s) && !/^-?[\d.]+$/.test(s);
+  }
+  function isNumeric(s) { return /^-?[\d.]+$/.test(s.trim()); }
+
+  const boundaries = [];
+  for (let i = 1; i < allFields.length - 1; i++) {
+    if (isNameToken(allFields[i]) && isNumeric(allFields[i + 1]) && isNameToken(allFields[i - 1])) {
+      boundaries.push(i);
+    }
+  }
+
+  const characters = [];
+  for (let b = 0; b < boundaries.length; b++) {
+    const start  = boundaries[b];
+    const end    = b + 1 < boundaries.length ? boundaries[b + 1] - 1 : allFields.length;
+    const fields = allFields.slice(start, end);
+    characters.push({
+      index:    b,
+      name:     allFields[start - 1].trim(),
+      alias:    fields[0].trim(),
+      fields,                   // fields[0]=alias, fields[1..]=numeric stats
+      startIdx: start,          // position in allFields — needed for writeBack
+    });
+  }
+  return { allFields, characters };
 }
 
-// Serialize back — exact inverse of parse, no newlines ever added
-function serializeChars(records) {
-  return records.map(r => r.join('|')).join('3');
+// Write edited characters back into the original allFields array and rejoin with '|'
+// edits: [{ characterIndex, fieldIndex, value }]
+function applyEdits(raw, edits) {
+  const { allFields, characters } = parseChars(raw);
+  for (const { characterIndex, fieldIndex, value } of edits) {
+    const ch = characters[characterIndex];
+    if (!ch) throw new Error(`Character index ${characterIndex} out of range`);
+    if (fieldIndex < 0 || fieldIndex >= ch.fields.length)
+      throw new Error(`Field index ${fieldIndex} out of range for character ${characterIndex}`);
+    // Write back into allFields at the correct absolute position
+    allFields[ch.startIdx + fieldIndex] = String(value);
+  }
+  return allFields.join('|');
 }
 
 // Extract characters.txt from an APK and save it to the session dir
@@ -223,15 +268,9 @@ app.post('/upload-url', async (req, res) => {
 // The frontend NEVER sees the raw blob — only structured data it needs to render.
 app.get('/characters/:token', (req, res) => {
   try {
-    const raw     = readChars(req.params.token);
-    const records = parseChars(raw);
-    const list    = records.map((fields, index) => ({
-      index,
-      name:   fields[0]  || '',
-      alias:  fields[1]  || '',
-      fields,             // full field array so the UI can render all editable values
-    }));
-    res.json({ count: list.length, characters: list });
+    const raw = readChars(req.params.token);
+    const { characters } = parseChars(raw);
+    res.json({ count: characters.length, characters });
   } catch (err) {
     res.status(404).json({ error: err.message });
   }
@@ -245,15 +284,10 @@ app.post('/edit', (req, res) => {
     return res.status(400).json({ error: 'Missing token, characterIndex, fieldIndex, or value' });
   }
   try {
-    const raw     = readChars(token);
-    const records = parseChars(raw);
-    const ci      = Number(characterIndex);
-    const fi      = Number(fieldIndex);
-    if (!records[ci]) return res.status(400).json({ error: `Character index ${ci} out of range` });
-    if (fi < 0 || fi >= records[ci].length) return res.status(400).json({ error: `Field index ${fi} out of range` });
-    records[ci][fi] = String(value);
-    writeChars(token, serializeChars(records));
-    res.json({ ok: true, characterIndex: ci, fieldIndex: fi, value: records[ci][fi] });
+    const raw    = readChars(token);
+    const edited = applyEdits(raw, [{ characterIndex: Number(characterIndex), fieldIndex: Number(fieldIndex), value }]);
+    writeChars(token, edited);
+    res.json({ ok: true, characterIndex: Number(characterIndex), fieldIndex: Number(fieldIndex), value: String(value) });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
@@ -265,16 +299,13 @@ app.post('/edit-bulk', (req, res) => {
   const { token, edits } = req.body;
   if (!token || !Array.isArray(edits)) return res.status(400).json({ error: 'Missing token or edits array' });
   try {
-    const raw     = readChars(token);
-    const records = parseChars(raw);
-    for (const { characterIndex, fieldIndex, value } of edits) {
-      const ci = Number(characterIndex);
-      const fi = Number(fieldIndex);
-      if (!records[ci]) throw new Error(`Character index ${ci} out of range`);
-      if (fi < 0 || fi >= records[ci].length) throw new Error(`Field index ${fi} out of range`);
-      records[ci][fi] = String(value);
-    }
-    writeChars(token, serializeChars(records));
+    const raw    = readChars(token);
+    const edited = applyEdits(raw, edits.map(e => ({
+      characterIndex: Number(e.characterIndex),
+      fieldIndex:     Number(e.fieldIndex),
+      value:          e.value,
+    })));
+    writeChars(token, edited);
     res.json({ ok: true, applied: edits.length });
   } catch (err) {
     res.status(500).json({ error: err.message });