@synopackageland/templates 0.26.5 → 0.27.1

package/templates/native-go-vue/frontend/DESIGN.md

@@ -43,16 +43,13 @@ Refresh and save expose busy state and localized errors. Reopen refreshes status
 Each mount owns its state; unmount unsubscribes from host events and ignores late
 responses. Backend route policies decide access.
 
-### Opt-in background schedules (S1-a)
+### Background jobs
 
-The `native-go-jobs` overlay extends this **Operate** surface within the inherited `AppRoot`, embedded theme, `SettingsSection`, Button and Callout system. It introduces no new palette or global tokens.
-
-- **Private-copy consent:** “Schedule this copy” is available for the signed-in owner's retained, successful, unscheduled job copy. “Private copy: {name}” identifies the input; “Repeat every” offers “Hour”, “Day” and “Week”. “Create schedule” stays disabled until the user checks “I agree to keep and reprocess this fixed copy as the package user. No new source files or personal ACLs are read.” The help explains the eight-schedule limit and that missed runs are recorded, never replayed.
-- **Ownership and recovery:** preserve user-and-UID owner isolation. Administrator rows expose “Owner: {user} (UID {uid})”. A worker change shows “The worker revision changed. An administrator must review and explicitly enable this schedule.” Only administrators, while background mode is on, see “Enable schedule”. Its confirmation names the exact private copy: “Enable the schedule for {name} with the current worker revision? I agree to reprocess this fixed copy. Past runs will not be replayed.” Actions are “Confirm enable” and “Cancel”.
-- **Layout:** schedule name/state, owner, next run, missed runs and warnings stack above a grouped, wrapping action row. Long names and copy wrap within the available width. Keep the inherited vertical scrolling at the minimum window size; do not squeeze schedules into one viewport. The labeled select and consent checkbox retain visible keyboard focus using existing theme tokens.
-- **Errors and cleanup:** danger alerts map known error codes to localized safe copy, with a localized fallback rather than raw server text. The catalogs cover nine locales. Preserve per-mount disposal: stop polling, dispose the picker, revoke result download URLs and prevent pending responses from restoring disposed state. Deletion confirmation explains that queued jobs cancel, running jobs drain and finished results remain.
-
-This layout is checked against the template's local component fixtures at the desktop size and at the DSM minimum window size, including the states and recovery copy above. That validates the component contract only; visual acceptance on a specific DSM release is the App developer's own check.
+Job producers import their own input into the App data directory. The backend
+keeps submission, progress, cancellation and private-copy scheduling contracts;
+the shell does not pick or import NAS files. App-specific job controls can use
+the installed SDK and UI components. Keep explicit consent for schedules and
+user-and-UID ownership isolation, and stop polling on unmount.
 
 ## Do's and Don'ts
 

package/templates/native-go-vue/frontend/src/App.vue

@@ -2,7 +2,7 @@
 import {computed, onMounted, onUnmounted, ref, watch} from 'vue'
 import {Button, Callout, Form, FormActions, FormItem, KeyValueRow, SettingsSection, Textarea} from '@synopackageland/ui'
 import {bridgeErrorCopy, sharedFolderAccessFor, type AppStatus, type Context, type ShellPage} from '@synopackageland/sdk'
-import {AppShell, BackgroundPanel, FilesPage, LoginPage, PortalSettings, SharedFolderSettings, createSession, shellPages} from '@synopackageland/sdk/vue'
+import {AppShell, FilesPage, LoginPage, PortalSettings, SharedFolderSettings, createSession, shellPages} from '@synopackageland/sdk/vue'
 import {appCopy} from './i18n'
 import CapabilityPanels from './CapabilityPanels.vue'
 import ExecutorGate, {holdsPages} from './ExecutorGate.vue'
@@ -66,11 +66,10 @@ async function refresh() {
 }
 // The header Refresh also reloads the panels below and reads the portal again.
 const panels = ref<{refresh(): unknown}>()
-const background = ref<{refresh(): unknown}>()
 const portalReads = ref(0)
 const portalKey = computed(() => `${app.value?.user}:${portalReads.value}`)
 function refreshAll() {
- void refresh(); void panels.value?.refresh(); void background.value?.refresh(); portalReads.value++
+ void refresh(); void panels.value?.refresh(); portalReads.value++
 }
 async function save() {
  if(disposed || busy.value) return
@@ -122,7 +121,6 @@ onUnmounted(()=>{disposed=true;unsubscribe?.();login.dispose();text.value=''})
    <CapabilityPanels v-if="app" ref="panels" :key="app.user" :ctx="ctx" :admin="app.admin" />
    <FilesPage v-if="page==='status'" :ctx="ctx" />
    <div data-page="background" v-show="page==='background'">
-    <BackgroundPanel v-if="backgroundEnabled && app" ref="background" :key="app.user" :ctx="ctx" />
    </div>
   </div>
   </ExecutorGate>

package/templates/native-node/README.md

@@ -111,7 +111,7 @@ rebuilding the SPK.
 
 | `--with` | Methods | Runtime services |
 | --- | --- | --- |
-| `jobs` | `hash.submit`, `hash.get`, `hash.cancel` | `files.read` with the caller's session, `bg.submit`, `bg.get`, `bg.cancel` |
+| `jobs` | `hash.submit`, `hash.get`, `hash.cancel` | Submit an App-owned imported file with `{key, name, input}` via `bg.submit`; look up or cancel the caller's job via `bg.get` / `bg.cancel` |
 | `root-ops` | `whoami.run` | `root.run` of `root/whoami.sh`, once an administrator approves the executor |
 | `delegate` | `report.save` | `delegate.move_from_staging` into a folder the caller chose |
 
@@ -158,3 +158,13 @@ ticks **Also delete the app data listed above** in the uninstall wizard.
 | Build hosts | macOS, Linux |
 | Target CPUs | x86_64 and aarch64 DSM models (one SPK each); armv7 is opt-in in `arches`, built but not NAS-verified |
 | DSM | 7.1 or later declared (`os_min_ver`) |
+
+## Background job input
+
+Jobs process an existing file imported by the App's producer into its private
+data directory. The submission params are `{key, name, input}`: an idempotency
+key, a display name and an absolute path inside that directory. The SDK keeps a
+bounded private copy for the worker; no browser session or NAS picker is used.
+Submit with `hash.submit`; use `hash.get` for progress and `hash.cancel` to
+cancel. These handlers call the existing `bg.submit`, `bg.get` and `bg.cancel`
+services; the runtime checks the input path and binds ownership to the caller.

package/templates/native-node-jobs/backend/src/jobs.ts

@@ -1,38 +1,11 @@
-// Background jobs: hash a NAS file the caller may read.
-//
-// The SDK's worker runs each job as the package account: it hashes the job's
-// input (SHA-256) and keeps the result for the job's owner, the caller. The
-// runtime serves files.read with the caller's DSM session and bg.* for the
-// caller's own jobs only.
-import { copyFileSync, mkdirSync, unlinkSync } from 'node:fs'
-import { randomUUID } from 'node:crypto'
-import { basename, join } from 'node:path'
-import { AppError, type App, type Context } from '@synopackageland/app'
+// Background jobs over files already imported into the App data directory.
+import type { App } from '@synopackageland/app'
 import { strings } from './params.js'
 import type { Config } from './routes.js'
 import { service } from './service.js'
 
-/** A job's input is at most 512 KiB, copied into the job when it is submitted. */
-const MAX_INPUT = 512 * 1024
-
-export function register(app: App, cfg: Config): void {
-  app.method('hash.submit', (ctx, params) => submit(cfg, ctx, params))
+export function register(app: App, _cfg: Config): void {
+  app.method('hash.submit', (ctx, params) => service(ctx, 'bg.submit', strings(params, 'key', 'name', 'input')))
   app.method('hash.get', (ctx, params) => service(ctx, 'bg.get', strings(params, 'id')))
   app.method('hash.cancel', (ctx, params) => service(ctx, 'bg.cancel', strings(params, 'id')))
 }
-
-async function submit(cfg: Config, ctx: Context, params: unknown) {
-  const { key, path } = strings(params, 'key', 'path')
-  const read = await service<{ path: string; size: number }>(ctx, 'files.read', { path })
-  if (read.size > MAX_INPUT) throw new AppError('limit_exceeded', 'The file is larger than allowed.')
-  // bg.submit takes its input from the data directory; the call's spool is elsewhere.
-  const inputs = join(cfg.dataDir, 'hash-inputs')
-  mkdirSync(inputs, { recursive: true, mode: 0o700 })
-  const input = join(inputs, randomUUID())
-  copyFileSync(read.path, input)
-  try {
-    return await service(ctx, 'bg.submit', { key, name: basename(path), input })
-  } finally {
-    unlinkSync(input)
-  }
-}

package/templates/native-node-jobs/backend/test/jobs.test.ts

@@ -1,64 +1,31 @@
 import assert from 'node:assert/strict'
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { mkdirSync, mkdtempSync, readdirSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
-import { join, sep } from 'node:path'
+import { join } from 'node:path'
 import { afterEach, beforeEach, test } from 'node:test'
 import { build, type Config } from '../src/routes.js'
-import { Refusal, call } from './support.js'
+import { call } from './support.js'
 
 const JOB = { job: { id: 'j1', state: 'queued' }, duplicate: false }
 let root: string
 let cfg: Config
-let submitted: Record<string, unknown>[]
 
 beforeEach(() => {
   root = mkdtempSync(join(tmpdir(), 'app-'))
   cfg = { packageId: 'ExampleApp', dataDir: join(root, 'var'), packagesRoot: join(root, 'packages') }
   mkdirSync(cfg.dataDir)
-  submitted = []
 })
 afterEach(() => rmSync(root, { recursive: true, force: true }))
 
-function spool(content: Buffer) {
-  const path = join(root, 'spool')
-  writeFileSync(path, content)
-  return { path, size: content.length }
-}
-
-// The runtime reads the input file while it answers bg.submit.
-function submit(params: unknown) {
-  const p = params as { input: string }
-  submitted.push({ ...p, content: readFileSync(p.input, 'utf8') })
-  return JOB
-}
-
-test('hash.submit hashes a copy of the caller\'s file', async () => {
-  const services = { 'files.read': () => spool(Buffer.from('hello')), 'bg.submit': submit }
-  const reply = await call(build(cfg), 'hash.submit', { key: 'k1', path: '/home/report.txt' }, { services })
-  assert.deepEqual(reply.data, JOB)
-  assert.deepEqual(reply.services.map(([op]) => op), ['files.read', 'bg.submit'])
-  assert.deepEqual(reply.services[0]![1], { path: '/home/report.txt' })
-  const [job] = submitted as [{ key: string; name: string; content: string; input: string }]
-  assert.deepEqual([job.key, job.name, job.content], ['k1', 'report.txt', 'hello'])
-  assert.ok(job.input.startsWith(cfg.dataDir + sep), job.input)
-  assert.equal(existsSync(job.input), false, 'the copy is removed once submitted')
-})
-
-test('hash.submit refuses a file over the job input limit', async () => {
-  const services = { 'files.read': () => spool(Buffer.alloc(512 * 1024 + 1)), 'bg.submit': submit }
-  const reply = await call(build(cfg), 'hash.submit', { key: 'k1', path: '/home/big.bin' }, { services })
-  assert.equal(reply.error?.code, 'limit_exceeded')
-  assert.deepEqual(submitted, [])
-})
-
-test('hash.submit passes on the runtime\'s refusal', async () => {
-  const services = { 'files.read': () => { throw new Refusal('read_failed', 'Unable to read the file.') } }
-  const reply = await call(build(cfg), 'hash.submit', { key: 'k1', path: '/home/a' }, { services })
-  assert.equal(reply.error?.code, 'read_failed')
+test('hash.submit passes imported input to the runtime', async () => {
+  const params = { key: 'k1', name: 'report.txt', input: join(cfg.dataDir, 'report.txt') }
+  const reply = await call(build(cfg), 'hash.submit', params, { services: { 'bg.submit': () => JOB } })
+  assert.deepEqual([reply.data, reply.services], [JOB, [['bg.submit', params]]])
+  assert.deepEqual(readdirSync(cfg.dataDir), [])
 })
 
 test('hash.submit refuses invalid params before any service', async () => {
-  for (const params of [null, { key: 'k1' }, { key: 1, path: '/home/a' }, { key: 'k1', path: '/home/a', x: 1 }]) {
+  for (const params of [null, { key: 'k1' }, { key: 1, name: 'a', input: '/app/a' }, { key: 'k1', name: 'a', input: '/app/a', x: 1 }]) {
     const reply = await call(build(cfg), 'hash.submit', params)
     assert.deepEqual([reply.error?.code, reply.services], ['bad_request', []], JSON.stringify(params))
   }

package/templates/native-python/README.md

@@ -108,7 +108,7 @@ rebuilding the SPK.
 
 | `--with` | Methods | Runtime services |
 | --- | --- | --- |
-| `jobs` | `hash.submit`, `hash.get`, `hash.cancel` | `files.read` with the caller's session, `bg.submit`, `bg.get`, `bg.cancel` |
+| `jobs` | `hash.submit`, `hash.get`, `hash.cancel` | Submit an App-owned imported file with `{key, name, input}` via `bg.submit`; look up or cancel the caller's job via `bg.get` / `bg.cancel` |
 | `root-ops` | `whoami.run` | `root.run` of `root/whoami.sh`, once an administrator approves the executor |
 | `delegate` | `report.save` | `delegate.move_from_staging` into a folder the caller chose |
 
@@ -155,3 +155,13 @@ ticks **Also delete the app data listed above** in the uninstall wizard.
 | Build hosts | macOS, Linux |
 | Target CPUs | x86_64 and aarch64 DSM models (one SPK each); armv7 is opt-in in `arches`, built but not NAS-verified |
 | DSM | 7.1 or later declared (`os_min_ver`) |
+
+## Background job input
+
+Jobs process an existing file imported by the App's producer into its private
+data directory. The submission params are `{key, name, input}`: an idempotency
+key, a display name and an absolute path inside that directory. The SDK keeps a
+bounded private copy for the worker; no browser session or NAS picker is used.
+Submit with `hash.submit`; use `hash.get` for progress and `hash.cancel` to
+cancel. These handlers call the existing `bg.submit`, `bg.get` and `bg.cancel`
+services; the runtime checks the input path and binds ownership to the caller.

package/templates/native-python-jobs/backend/app/jobs.py

@@ -1,40 +1,8 @@
-"""Background jobs: hash a NAS file the caller may read.
-
-The SDK's worker runs each job as the package account: it hashes the job's
-input (SHA-256) and keeps the result for the job's owner, the caller. The
-runtime serves files.read with the caller's DSM session and bg.* for the
-caller's own jobs only.
-"""
-
-import os
-import shutil
-import tempfile
-
-from synopkgland_app import Error
-
+"""Background jobs over files already imported into the App data directory."""
 from params import fields
 
-# A job's input is at most 512 KiB, copied into the job when it is submitted.
-MAX_INPUT = 512 * 1024
-
 
 def register(app, cfg):
-    app.method("hash.submit")(lambda ctx, params: submit(cfg, ctx, params))
+    app.method("hash.submit")(lambda ctx, params: ctx.runtime("bg.submit", fields(params, key=str, name=str, input=str)))
     app.method("hash.get")(lambda ctx, params: ctx.runtime("bg.get", fields(params, id=str)))
     app.method("hash.cancel")(lambda ctx, params: ctx.runtime("bg.cancel", fields(params, id=str)))
-
-
-def submit(cfg, ctx, params):
-    p = fields(params, key=str, path=str)
-    read = ctx.runtime("files.read", {"path": p["path"]})
-    if read["size"] > MAX_INPUT:
-        raise Error("limit_exceeded", "The file is larger than allowed.")
-    # bg.submit takes its input from the data directory; the call's spool is elsewhere.
-    inputs = os.path.join(cfg.data_dir, "hash-inputs")
-    os.makedirs(inputs, mode=0o700, exist_ok=True)
-    with open(read["path"], "rb") as source, tempfile.NamedTemporaryFile(dir=inputs, delete=False) as copy:
-        shutil.copyfileobj(source, copy)
-    try:
-        return ctx.runtime("bg.submit", {"key": p["key"], "name": os.path.basename(p["path"]), "input": copy.name})
-    finally:
-        os.unlink(copy.name)

package/templates/native-python-jobs/backend/tests/test_jobs.py

@@ -2,7 +2,7 @@ import os
 import tempfile
 import unittest
 
-from support import Error, call
+from support import call
 
 import routes
 
@@ -16,46 +16,15 @@ class JobsTest(unittest.TestCase):
         self.data = os.path.join(self.dir.name, "var")
         os.mkdir(self.data)
         self.app = routes.build(routes.Config("ExampleApp", self.data))
-        self.submitted = []
 
-    def spool(self, content):
-        path = os.path.join(self.dir.name, "spool")
-        with open(path, "wb") as f:
-            f.write(content)
-        return {"path": path, "size": len(content)}
-
-    def submit(self, params):
-        # The runtime reads the input file while it answers bg.submit.
-        with open(params["input"], "rb") as f:
-            self.submitted.append(dict(params, content=f.read()))
-        return JOB
-
-    def test_submit_hashes_a_copy_of_the_callers_file(self):
-        services = {"files.read": lambda p: self.spool(b"hello"), "bg.submit": self.submit}
-        reply = call(self.app, "hash.submit", {"key": "k1", "path": "/home/report.txt"}, services=services)
-        self.assertEqual(reply.data, JOB)
-        self.assertEqual([op for op, _ in reply.services], ["files.read", "bg.submit"])
-        self.assertEqual(reply.services[0][1], {"path": "/home/report.txt"})
-        [submitted] = self.submitted
-        self.assertEqual((submitted["key"], submitted["name"], submitted["content"]), ("k1", "report.txt", b"hello"))
-        self.assertTrue(submitted["input"].startswith(self.data + os.sep))
-        self.assertFalse(os.path.exists(submitted["input"]), "the copy is removed once submitted")
-
-    def test_submit_refuses_a_file_over_the_job_input_limit(self):
-        services = {"files.read": lambda p: self.spool(b"x" * (512 * 1024 + 1)), "bg.submit": self.submit}
-        reply = call(self.app, "hash.submit", {"key": "k1", "path": "/home/big.bin"}, services=services)
-        self.assertEqual(reply.error["code"], "limit_exceeded")
-        self.assertEqual(self.submitted, [])
-
-    def test_submit_passes_on_the_runtimes_refusal(self):
-        def unreadable(params):
-            raise Error("read_failed", "Unable to read the file.")
-
-        reply = call(self.app, "hash.submit", {"key": "k1", "path": "/home/a"}, services={"files.read": unreadable})
-        self.assertEqual(reply.error["code"], "read_failed")
+    def test_submit_passes_imported_input_to_the_runtime(self):
+        params = {"key": "k1", "name": "report.txt", "input": os.path.join(self.data, "report.txt")}
+        reply = call(self.app, "hash.submit", params, services={"bg.submit": lambda p: JOB})
+        self.assertEqual((reply.data, reply.services), (JOB, [("bg.submit", params)]))
+        self.assertEqual(os.listdir(self.data), [])
 
     def test_submit_refuses_invalid_params_before_any_service(self):
-        for params in [None, {"key": "k1"}, {"key": 1, "path": "/home/a"}, {"key": "k1", "path": "/home/a", "x": 1}]:
+        for params in [None, {"key": "k1"}, {"key": 1, "name": "a", "input": "/app/a"}, {"key": "k1", "name": "a", "input": "/app/a", "x": 1}]:
             with self.subTest(params=params):
                 reply = call(self.app, "hash.submit", params)
                 self.assertEqual((reply.error["code"], reply.services), ("bad_request", []))

package/templates/native-rust/README.md

@@ -117,7 +117,7 @@ rebuilding the SPK.
 
 | `--with` | Methods | Runtime services |
 | --- | --- | --- |
-| `jobs` | `hash.submit`, `hash.get`, `hash.cancel` | `files.read` with the caller's session, `bg.submit`, `bg.get`, `bg.cancel` |
+| `jobs` | `hash.submit`, `hash.get`, `hash.cancel` | Submit an App-owned imported file with `{key, name, input}` via `bg.submit`; look up or cancel the caller's job via `bg.get` / `bg.cancel` |
 | `root-ops` | `whoami.run` | `root.run` of `root/whoami.sh`, once an administrator approves the executor |
 | `delegate` | `report.save` | `delegate.move_from_staging` into a folder the caller chose |
 
@@ -164,3 +164,13 @@ ticks **Also delete the app data listed above** in the uninstall wizard.
 | Build hosts | macOS, Linux |
 | Target CPUs | x86_64 and aarch64 DSM models (one SPK each); armv7 is opt-in in `arches`, built but not NAS-verified |
 | DSM | 7.1 or later declared (`os_min_ver`) |
+
+## Background job input
+
+Jobs process an existing file imported by the App's producer into its private
+data directory. The submission params are `{key, name, input}`: an idempotency
+key, a display name and an absolute path inside that directory. The SDK keeps a
+bounded private copy for the worker; no browser session or NAS picker is used.
+Submit with `hash.submit`; use `hash.get` for progress and `hash.cancel` to
+cancel. These handlers call the existing `bg.submit`, `bg.get` and `bg.cancel`
+services; the runtime checks the input path and binds ownership to the caller.

package/templates/native-rust-jobs/backend/src/jobs.rs

@@ -1,90 +1,41 @@
-//! Background jobs: hash a NAS file the caller may read.
-//!
-//! The SDK's worker runs each job as the package account: it hashes the job's
-//! input (SHA-256) and keeps the result for the job's owner, the caller. The
-//! runtime serves files.read with the caller's DSM session and bg.* for the
-//! caller's own jobs only.
-
-use crate::routes::{Config, internal};
+//! Background jobs over files already imported into the App data directory.
+use crate::routes::Config;
 use serde::Deserialize;
 use serde_json::{Value, json};
-use std::os::unix::fs::DirBuilderExt;
-use std::path::{Path, PathBuf};
 use syno_pkg_land_app::{App, Context, Error, Params};
 
-/// A job's input is at most 512 KiB, copied into the job when it is submitted.
-const MAX_INPUT: u64 = 512 * 1024;
-
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct Submit {
     key: String,
-    path: String,
+    name: String,
+    input: String,
 }
-
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct JobId {
     id: String,
 }
 
-#[derive(Deserialize)]
-struct Read {
-    path: PathBuf,
-    size: u64,
-}
-
-pub fn register(app: &mut App, cfg: &Config) {
-    let cfg = cfg.clone();
-    app.method("hash.submit", move |ctx, params| submit(&cfg, ctx, params));
+pub fn register(app: &mut App, _cfg: &Config) {
+    app.method("hash.submit", |ctx, params| -> Result<Value, Error> {
+        let Submit { key, name, input } = params.decode()?;
+        ctx.runtime(
+            "bg.submit",
+            &json!({"key": key, "name": name, "input": input}),
+        )
+    });
     app.method("hash.get", |ctx, params| job(ctx, "bg.get", params));
     app.method("hash.cancel", |ctx, params| job(ctx, "bg.cancel", params));
 }
-
 fn job(ctx: &Context, op: &str, params: &Params) -> Result<Value, Error> {
     let JobId { id } = params.decode()?;
     ctx.runtime(op, &json!({"id": id}))
 }
-
-fn submit(cfg: &Config, ctx: &Context, params: &Params) -> Result<Value, Error> {
-    let p: Submit = params.decode()?;
-    let read: Read = ctx.runtime("files.read", &json!({"path": p.path}))?;
-    if read.size > MAX_INPUT {
-        return Err(Error::new(
-            "limit_exceeded",
-            "The file is larger than allowed.",
-        ));
-    }
-    // bg.submit takes its input from the data directory; the call's spool is elsewhere.
-    let inputs = cfg.data_dir.join("hash-inputs");
-    std::fs::DirBuilder::new()
-        .recursive(true)
-        .mode(0o700)
-        .create(&inputs)
-        .map_err(internal)?;
-    let copy = inputs.join(&ctx.request_id);
-    std::fs::copy(&read.path, &copy).map_err(internal)?;
-    let name = Path::new(&p.path)
-        .file_name()
-        .map_or(String::new(), |n| n.to_string_lossy().into_owned());
-    let submitted = ctx.runtime(
-        "bg.submit",
-        &json!({"key": p.key, "name": name, "input": copy}),
-    );
-    let _ = std::fs::remove_file(&copy);
-    submitted
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::test_support::{Services, TempDir, call};
-    use serde_json::{Value, json};
-    use std::sync::{Arc, Mutex};
-
-    /// What bg.submit was asked: its params and the input it read.
-    type Submitted = Arc<Mutex<Vec<(Value, Vec<u8>)>>>;
-
     fn setup() -> (TempDir, Config) {
         let dir = TempDir::new();
         let cfg = Config {
@@ -100,102 +51,30 @@ mod tests {
         json!({"job": {"id": "j1", "state": "queued"}, "duplicate": false})
     }
 
-    /// files.read answers a spool file with content; bg.submit records its params and the input it read.
-    fn services(dir: &TempDir, content: Vec<u8>, submitted: &Submitted) -> Services {
-        let spool = dir.path().join("spool");
-        std::fs::write(&spool, &content).unwrap();
-        let read = json!({"path": spool, "size": content.len()});
-        let submitted = submitted.clone();
-        [
-            (
-                "files.read",
-                Box::new(move |_: &Value| Ok(read.clone())) as _,
-            ),
-            (
-                "bg.submit",
-                Box::new(move |p: &Value| {
-                    // The runtime reads the input file while it answers bg.submit.
-                    let input = std::fs::read(p["input"].as_str().unwrap()).unwrap();
-                    submitted.lock().unwrap().push((p.clone(), input));
-                    Ok(job())
-                }) as _,
-            ),
-        ]
-        .into()
-    }
-
     #[test]
-    fn submit_hashes_a_copy_of_the_callers_file() {
-        let (dir, cfg) = setup();
-        let submitted = Arc::new(Mutex::new(Vec::new()));
-        let services = services(&dir, b"hello".to_vec(), &submitted);
-        let reply = call(
-            crate::routes::build(cfg.clone()),
-            "hash.submit",
-            json!({"key": "k1", "path": "/home/report.txt"}),
-            "alice",
-            &services,
-        );
-        assert_eq!(reply.data, job());
-        let ops: Vec<_> = reply.services.iter().map(|(op, _)| op.as_str()).collect();
-        assert_eq!(ops, ["files.read", "bg.submit"]);
-        assert_eq!(reply.services[0].1, json!({"path": "/home/report.txt"}));
-        let submitted = submitted.lock().unwrap();
-        let (params, content) = &submitted[0];
-        assert_eq!(
-            (&params["key"], &params["name"], content.as_slice()),
-            (&json!("k1"), &json!("report.txt"), b"hello".as_slice())
-        );
-        let input = params["input"].as_str().unwrap();
-        assert!(input.starts_with(cfg.data_dir.to_str().unwrap()), "{input}");
-        assert!(
-            !std::path::Path::new(input).exists(),
-            "the copy is removed once submitted"
-        );
-    }
-
-    #[test]
-    fn submit_refuses_a_file_over_the_job_input_limit() {
-        let (dir, cfg) = setup();
-        let submitted = Arc::new(Mutex::new(Vec::new()));
-        let services = services(&dir, vec![0; MAX_INPUT as usize + 1], &submitted);
-        let reply = call(
-            crate::routes::build(cfg),
-            "hash.submit",
-            json!({"key": "k1", "path": "/home/big.bin"}),
-            "alice",
-            &services,
-        );
-        assert_eq!(reply.code(), "limit_exceeded");
-        assert!(submitted.lock().unwrap().is_empty());
-    }
-
-    #[test]
-    fn submit_passes_on_the_runtimes_refusal() {
+    fn submit_passes_imported_input_to_the_runtime() {
         let (_dir, cfg) = setup();
-        let services: Services = [(
-            "files.read",
-            Box::new(|_: &Value| Err(Error::new("read_failed", "Unable to read the file."))) as _,
-        )]
-        .into();
+        let params =
+            json!({"key":"k1","name":"report.txt","input":cfg.data_dir.join("report.txt")});
+        let services: Services = [("bg.submit", Box::new(|_: &Value| Ok(job())) as _)].into();
         let reply = call(
             crate::routes::build(cfg),
             "hash.submit",
-            json!({"key": "k1", "path": "/home/a"}),
+            params.clone(),
             "alice",
             &services,
         );
-        assert_eq!(reply.code(), "read_failed");
+        assert_eq!(reply.data, job());
+        assert_eq!(reply.services, vec![("bg.submit".to_string(), params)]);
     }
-
     #[test]
     fn submit_refuses_invalid_params_before_any_service() {
         let (_dir, cfg) = setup();
         for params in [
             Value::Null,
             json!({"key": "k1"}),
-            json!({"key": 1, "path": "/home/a"}),
-            json!({"key": "k1", "path": "/home/a", "x": 1}),
+            json!({"key": 1, "name": "a", "input": "/app/a"}),
+            json!({"key": "k1", "name": "a", "input": "/app/a", "x": 1}),
         ] {
             let reply = call(
                 crate::routes::build(cfg.clone()),

package/templates/native-go-jobs/frontend/test/background-page.test.ts

@@ -1,59 +0,0 @@
-// @vitest-environment jsdom
-import {expect,test,vi} from 'vitest'
-import {nextTick} from 'vue'
-import {mount} from '../src/main'
-import {dsmWindow} from './context'
-async function settle(){for(let i=0;i<20;i++){await Promise.resolve();await nextTick()}}
-// The CLI turns the background page on for jobs (and delegate) projects only.
-test('a jobs project mounts the background panel for the signed-in user',async()=>{
- const call=vi.fn(async(method:string)=>{
-  if(method==='app.status')return {package:'Jobs',version:'1',user:'alice',admin:false}
-  throw {code:'unknown_method'}
- })
- const root=document.createElement('div');document.body.append(root)
- const app=mount(root,dsmWindow({call}))
- try{
-  await settle()
-  expect(call.mock.calls.some(([method])=>method.startsWith('bg.'))).toBe(true)
-  expect(root.querySelector('[data-page="background"]')).not.toBeNull()
- }finally{app.unmount();root.remove()}
-})
-test('the background panel pauses a running job and resumes a paused one',async()=>{
- const submitter={user:'alice',uid:'1024'}
- const jobs=[{id:'run',name:'a.bin',state:'running',submitter},{id:'held',name:'b.bin',state:'paused',pauseReason:'user',submitter}]
- const call=vi.fn(async(method:string):Promise<unknown>=>{
-  if(method==='app.status')return {package:'Jobs',version:'1',user:'alice',admin:false}
-  if(method==='bg.status')return {owner:submitter,admin:false,revision:1,worker:{username:'pkg',alive:true},limits:{maxInputBytes:1024,maxQueued:8,maxOwnerPending:4,maxOwnerBytes:4096,jobTimeoutSeconds:60}}
-  if(method==='bg.jobs.list')return {jobs}
-  if(method==='bg.schedules.list')return {schedules:[]}
-  return {}
- })
- const root=document.createElement('div');document.body.append(root)
- const app=mount(root,dsmWindow({call}))
- const button=(id:string,label:string)=>Array.from(root.querySelectorAll(`[data-job-id="${id}"] button`)).find(b=>b.textContent===label) as HTMLButtonElement|undefined
- try{
-  await settle()
-  button('run','Pause')!.click();await settle()
-  expect(call).toHaveBeenCalledWith('bg.jobs.pause',{id:'run'})
-  button('held','Resume')!.click();await settle()
-  expect(call).toHaveBeenCalledWith('bg.jobs.resume',{id:'held'})
- }finally{app.unmount();root.remove()}
-})
-test('the header Refresh reloads the background panel',async()=>{
- const call=vi.fn(async(method:string):Promise<unknown>=>{
-  if(method==='app.status')return {package:'Jobs',version:'1',user:'alice',admin:false}
-  if(method==='bg.status')return {owner:{user:'alice',uid:'1024'},admin:false,revision:1,worker:{username:'pkg',alive:true},limits:{maxInputBytes:1024,maxQueued:8,maxOwnerPending:4,maxOwnerBytes:4096,jobTimeoutSeconds:60}}
-  if(method==='bg.jobs.list')return {jobs:[]}
-  if(method==='bg.schedules.list')return {schedules:[]}
-  return {}
- })
- const root=document.createElement('div');document.body.append(root)
- const app=mount(root,dsmWindow({call}))
- const reads=()=>call.mock.calls.filter(([method])=>method==='bg.jobs.list').length
- try{
-  await settle();const before=reads()
-  // The header button comes first; the panels below may have their own.
-  ;(Array.from(root.querySelectorAll('button')).find(b=>b.textContent==='Refresh') as HTMLButtonElement).click();await settle()
-  expect(reads()).toBeGreaterThan(before)
- }finally{app.unmount();root.remove()}
-})