openrod 0.0.0 → 0.1.0

package/server/orphan-processes.js

@@ -0,0 +1,42 @@
+import path from 'node:path'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const run = promisify(execFile)
+
+// The console starts its remote gateway and SSH tunnel in their own process
+// groups so a stop reaches their children. The cost: if the console dies
+// without cleaning up (SIGKILL, crash, a dev server being stopped), they are
+// reparented to init and keep running. The old tunnel still holds its reverse
+// port on the remote host, so every later connect fails with "remote port
+// forwarding failed". An orphan is one of our processes whose parent is init;
+// a live console's children always have that console as their parent.
+export function findOrphans(listing, { stateRoot, user = null }) {
+  const gatewayConfigs = path.join(stateRoot, 'remote-gateways') + path.sep
+  const found = []
+  for (const line of listing.split('\n')) {
+    const match = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(line)
+    if (!match) continue
+    const [, pid, ppid, command] = match
+    if (ppid !== '1' || Number(pid) === process.pid) continue
+    const tunnel = command.includes('ExitOnForwardFailure=yes') && command.includes('StreamLocalBindMask=0177') && /\bos-ssh-[^/\s]+\/docker\.sock/.test(command)
+    const gateway = /openshell-gateway\b/.test(command) && command.includes(`--config ${gatewayConfigs}`)
+    if (tunnel || gateway) found.push({ pid: Number(pid), kind: tunnel ? 'tunnel' : 'gateway', command })
+  }
+  return found
+}
+
+export async function reapOrphans({ stateRoot, logger = console, timeoutMs = 2000 } = {}) {
+  if (process.platform === 'win32') return []
+  let listing
+  try { listing = (await run('ps', ['-x', '-o', 'pid=,ppid=,command='], { maxBuffer: 8 * 1024 * 1024 })).stdout } catch { return [] }
+  const orphans = findOrphans(listing, { stateRoot })
+  const signal = (orphan, name) => { try { process.kill(-orphan.pid, name) } catch { try { process.kill(orphan.pid, name) } catch { /* already gone */ } } }
+  for (const orphan of orphans) signal(orphan, 'SIGTERM')
+  const alive = pid => { try { process.kill(pid, 0); return true } catch { return false } }
+  const deadline = Date.now() + timeoutMs
+  while (orphans.some(orphan => alive(orphan.pid)) && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 100))
+  for (const orphan of orphans) if (alive(orphan.pid)) signal(orphan, 'SIGKILL')
+  for (const orphan of orphans) logger.warn(`Stopped a leftover remote ${orphan.kind} from an earlier console run (pid ${orphan.pid}).`)
+  return orphans
+}

package/server/paths.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { createHash } from 'node:crypto'
+import { contextKey, contextSelection } from './gateway.js'
+
+// Installed packages are read-only. All mutable console data lives with the user.
+export function stateDirectory() {
+  return path.resolve(process.env.OPENSHELL_CONSOLE_DATA_DIR || path.join(process.env.XDG_STATE_HOME || path.join(os.homedir(), '.local/state'), 'openshell-console'))
+}
+
+export function scopedStateDirectory(context = contextSelection()) {
+  const scope = createHash('sha256').update(contextKey(context)).digest('hex')
+  return path.join(stateDirectory(), 'contexts', scope)
+}
+
+// Every context starts with empty policies: built-in templates live in code, and
+// egress rules, groups and memberships are only ever authored by the operator.
+const policyDirectories = new Map()
+export async function policyDirectory() {
+  const directory = path.join(scopedStateDirectory(), 'policies')
+  if (!policyDirectories.has(directory)) {
+    const ready = fs.mkdir(directory, { recursive: true, mode: 0o700 }).then(() => directory)
+    policyDirectories.set(directory, ready)
+    ready.catch(() => policyDirectories.delete(directory))
+  }
+  return policyDirectories.get(directory)
+}

package/server/policy-template-store.js

@@ -0,0 +1,92 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { randomUUID } from 'node:crypto'
+import { composeTemplate } from '../shared/policy-templates.js'
+
+const fail = (message, status = 400) => Object.assign(new Error(message), { status })
+
+// One atomic catalog overlay stores edits and deletions, including built-ins.
+// Existing custom JSON files remain readable and are never rewritten by migration.
+export function createTemplateStore({ directory, builtins, legacy = [], validate }) {
+  const statePath = path.join(directory, 'catalog', 'templates.json')
+  let pending = Promise.resolve()
+  const mutate = (operation) => {
+    const next = pending.then(operation)
+    pending = next.catch(() => {})
+    return next
+  }
+  async function state() {
+    try { return JSON.parse(await fs.readFile(statePath, 'utf8')) }
+    catch (error) { if (error.code === 'ENOENT') return { templates: {}, deleted: [] }; throw error }
+  }
+  async function write(value) {
+    await fs.mkdir(path.dirname(statePath), { recursive: true })
+    const temporary = `${statePath}.${randomUUID()}.tmp`
+    try {
+      await fs.writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`)
+      await fs.rename(temporary, statePath)
+    } finally { await fs.rm(temporary, { force: true }) }
+  }
+  async function list(current = null) {
+    current ??= await state()
+    const catalog = new Map(builtins.map(template => [template.id, template]))
+    let files = []
+    try { files = await fs.readdir(directory) } catch (error) { if (error.code !== 'ENOENT') throw error }
+    for (const file of files.filter(name => name.endsWith('.json'))) {
+      try {
+        const template = validate(JSON.parse(await fs.readFile(path.join(directory, file), 'utf8')))
+        if (!catalog.has(template.id)) catalog.set(template.id, template)
+      } catch { /* Ignore malformed legacy custom files, as before. */ }
+    }
+    for (const value of Object.values(current.templates)) {
+      const template = validate(value)
+      catalog.set(template.id, template)
+    }
+    for (const id of current.deleted) catalog.delete(id)
+    return [...catalog.values()]
+  }
+  async function groups() {
+    const folder = path.join(directory, 'org', 'groups')
+    let files
+    try { files = await fs.readdir(folder) } catch (error) { if (error.code === 'ENOENT') return []; throw error }
+    return Promise.all(files.filter(file => file.endsWith('.json')).map(async file => JSON.parse(await fs.readFile(path.join(folder, file), 'utf8'))))
+  }
+  return {
+    list,
+    async find(id) {
+      const current = await state()
+      if (current.deleted.includes(id)) return null
+      return (await list(current)).find(template => template.id === id) ?? legacy.find(template => template.id === id) ?? null
+    },
+    save: (input) => mutate(async () => {
+      const template = validate(input)
+      const current = await state()
+      const catalog = (await list(current)).filter(item => item.id !== template.id).concat(template)
+      // An edited addition must also remain compatible with saved combinations.
+      for (const item of catalog) {
+        try { composeTemplate(item, [], catalog) }
+        catch (error) { throw fail(`${item.name}: ${error.message}`) }
+      }
+      current.templates[template.id] = template
+      current.deleted = current.deleted.filter(id => id !== template.id)
+      await write(current)
+      return template
+    }),
+    deleteMany: (ids) => mutate(async () => {
+      if (!Array.isArray(ids) || !ids.length || ids.length > 200 || ids.some(id => typeof id !== 'string' || !/^[a-z0-9][a-z0-9-]{0,47}$/.test(id))) throw fail('Choose policies to delete.')
+      const targets = new Set(ids)
+      const current = await state()
+      const catalog = await list(current)
+      for (const template of catalog.filter(item => !targets.has(item.id))) {
+        if (template.accessTemplates?.some(id => targets.has(id))) throw fail(`"${template.name}" uses a selected policy. Edit it or include it in the deletion.`, 409)
+      }
+      for (const group of await groups()) {
+        if (targets.has(group.template)) throw fail(`Group "${group.name || group.id}" uses a selected policy. Change the group's policy first.`, 409)
+      }
+      current.deleted = [...new Set([...current.deleted, ...targets])]
+      for (const id of targets) delete current.templates[id]
+      await write(current)
+      return { deleted: [...targets] }
+    }),
+  }
+}