phio 0.0.1

package/README.md

@@ -0,0 +1,48 @@
+# phio: the pockethost.io CLI
+
+**Auth**
+
+```bash
+bunx phio login
+```
+
+**Watch and push local changes instantly**
+
+```bash
+bunx phio dev [instance]
+```
+
+**Bi-directional sync**
+
+```bash
+bunx phio sync [instance]
+```
+
+**Tail logs**
+
+```bash
+bunx phio logs [instance]
+```
+
+## Configuration
+
+Use `pockethost` in your `package.json` to save your instance name so you don't need to keep typing it:
+
+```json
+// package.json
+{
+  "pockethost": {
+    "instanceId": "all-your-base"
+  }
+}
+```
+
+-or-
+
+Use `pockethost.json` to save your instance name so you don't need to keep typing it.
+
+```json
+{
+    "instanceId": "all-your-base'
+}
+```

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "phio",
+  "version": "0.0.1",
+  "description": "A CLI tool to manage your PocketHost instances",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/benallfree/phio"
+  },
+  "homepage": "https://github.com/benallfree/phio",
+  "keywords": [
+    "cli",
+    "pocketbase",
+    "pockethost"
+  ],
+  "author": "Ben Allfree",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/benallfree/phio/issues"
+  },
+  "module": "src/index.ts",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.5.5"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "dev": "tsx --watch ./src/index.ts"
+  },
+  "bin": {
+    "phio": "src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^5.5.0",
+    "@s-libs/micro-dash": "^18.0.0",
+    "@samkirkland/ftp-deploy": "^1.2.4",
+    "@sentool/fetch-event-source": "^0.5.0",
+    "chokidar": "^4.0.0",
+    "commander": "^12.1.0",
+    "email-validator": "^2.0.4",
+    "env-paths": "^3.0.0",
+    "env-var": "^7.5.0",
+    "event-stream": "^4.0.1",
+    "fs-extra": "^11.2.0",
+    "ora": "^8.1.0",
+    "pocketbase": "^0.21.5"
+  }
+}

package/src/DevCommand.ts

@@ -0,0 +1,67 @@
+import { Command } from 'commander'
+import { config } from './config'
+import { deploy, excludeDefaults } from '@samkirkland/ftp-deploy'
+import { getClient } from './getClient'
+import { ensureDirSync } from 'fs-extra'
+import { defaultInstanceId } from './defaultInstanceId'
+import { watch } from 'chokidar'
+import { file } from 'bun'
+import { basename, dirname } from 'path'
+import { debounce } from '@s-libs/micro-dash'
+
+async function deployMyCode(instanceName: string) {
+  const cachePath = '.cache'
+  ensureDirSync(cachePath)
+
+  console.log('🚚 Deploy started')
+  await deploy({
+    server: 'ftp.pockethost.io',
+    username: `__auth__`,
+    password: config(`auth`)!.token,
+    'server-dir': `${instanceName}/`,
+    exclude: ['*', '!pb_*/**/*'],
+    'state-name': '.cache/.ftp-deploy-sync-state.json',
+    'log-level': 'verbose',
+  })
+  console.log('🚀 Deploy done!')
+}
+
+export const DevCommand = () => {
+  return new Command('dev')
+    .argument(`[instanceId]`, `Instance name`, defaultInstanceId())
+    .description(`Watch for local modifications and sync to remote`)
+    .action(async (_instanceId) => {
+      if (!_instanceId) {
+        console.error(
+          'No instance name provided and none was found in package.json or pockethost.json'
+        )
+        process.exit(1)
+      }
+
+      const client = getClient()
+
+      const instance = await client
+        .collection(`instances`)
+        .getFirstListItem(`id='${_instanceId}' || subdomain='${_instanceId}'`)
+
+      const upload = debounce(() => {
+        deployMyCode(instance.subdomain).catch(console.error)
+      }, 200)
+
+      const watcher = watch(['.'], {
+        persistent: true,
+        ignored: (file) => {
+          const isIgnored = file !== '.' && !file.startsWith('pb_')
+          // console.log({ file, isIgnored })
+          return isIgnored
+        },
+      })
+      console.log(`Watching for changes in pb_*/**/*`)
+      const handle = (path: string, details: any) => {
+        upload()
+        // internal
+        console.log({ path, details })
+      }
+      watcher.on('add', handle).on('change', handle).on('unlink', handle)
+    })
+}

package/src/LoginCommand.ts

@@ -0,0 +1,59 @@
+import { input, password } from '@inquirer/prompts'
+import { Command } from 'commander'
+import * as EmailValidator from 'email-validator'
+//@ts-ignore
+import { runTasks } from './Task'
+import { config } from './config'
+import { getClient } from './getClient'
+
+export const LoginCommand = () =>
+  new Command('login')
+    .description(`Log in to PocketHost`)
+    .helpOption(false)
+    .action(async () => {
+      while (true) {
+        const email = await input({
+          message: 'Enter your pockethost.io email address',
+          default: config('email'),
+          validate: (input: string) => {
+            if (!EmailValidator.validate(input)) {
+              return 'Invalid email address'
+            }
+            return true
+          },
+        })
+
+        const pw = await password({
+          message: 'Enter your pockethost.io password',
+        })
+
+        config(`email`, email)
+
+        const client = getClient()
+        try {
+          await runTasks([
+            {
+              name: `Logging in`,
+              run: async () => {
+                const res = await client
+                  .collection('users')
+                  .authWithPassword(email, pw)
+                console.log({ res })
+              },
+            },
+          ])
+        } catch (e) {
+          console.error(
+            `There was an error logging in. Please try again or go to https://pockethost.io to reset your password.`
+          )
+          continue
+        }
+
+        config(`auth`, {
+          token: client.authStore.exportToCookie(),
+          record: client.authStore.model,
+        })
+        break
+      }
+      console.log(`Logged in!`)
+    })

package/src/LogsCommand.ts

@@ -0,0 +1,77 @@
+import { Command } from 'commander'
+import { config } from './config'
+//@ts-ignore
+import { fetchEventSource } from '@sentool/fetch-event-source'
+
+export enum StreamNames {
+  StdOut = 'stdout',
+  StdErr = 'stderr',
+}
+
+export type InstanceLogFields = {
+  message: string
+  time: string
+  stream: StreamNames
+}
+const watchInstanceLog = (
+  instanceId: string,
+  update: (log: InstanceLogFields) => void,
+  nInitial = 100
+): (() => void) => {
+  const controller = new AbortController()
+  const signal = controller.signal
+  const continuallyFetchFromEventSource = () => {
+    const url = `https://${instanceId}.pockethost.io/logs`
+    const body = {
+      instanceId,
+      n: nInitial,
+      auth: config(`auth`)!.token,
+    }
+
+    fetchEventSource(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      openWhenHidden: true,
+      body: JSON.stringify(body),
+      onmessage: (event: any) => {
+        const { data } = event
+
+        update(data)
+      },
+      onopen: async (response: Response) => {
+        // console.log(response)
+      },
+      onerror: (e: Error) => {
+        console.error(`got an error`, e)
+      },
+      onclose: () => {
+        console.log(`closed`)
+        setTimeout(continuallyFetchFromEventSource, 100)
+      },
+      signal,
+    })
+  }
+  continuallyFetchFromEventSource()
+
+  return () => {
+    controller.abort()
+  }
+}
+
+export const LogsCommand = () => {
+  return new Command('logs')
+    .description(`Tail instance logs`)
+    .argument('<instance>', 'Instance ID')
+    .action((instance) => {
+      watchInstanceLog(instance, (log) => {
+        const { time, message, stream } = log
+        if (stream === 'stderr') {
+          console.error(`[${time}] ${message}`)
+        } else {
+          console.log(`[${time}] ${message}`)
+        }
+      })
+    })
+}

package/src/Task.ts

@@ -0,0 +1,19 @@
+import ora from 'ora'
+
+interface Task {
+  name: string
+  run: () => Promise<any>
+}
+export async function runTasks(tasks: Task[]): Promise<void> {
+  for (const task of tasks) {
+    const spinner = ora(`${task.name}...`).start()
+
+    try {
+      await task.run()
+      spinner.succeed(`${task.name}`)
+    } catch (error) {
+      spinner.fail(`${task.name}`)
+      throw error
+    }
+  }
+}

package/src/config.ts

@@ -0,0 +1,35 @@
+import { readJSONSync, writeJSONSync } from 'fs-extra/esm'
+import { type AuthModel } from 'pocketbase'
+import { PHIO_HOME } from './constants'
+
+export type Config = {
+  email: string
+  auth: { record: AuthModel; token: string }
+}
+export function config<T extends keyof Config>(
+  k: T,
+  v?: Config[T]
+): Config[T] | undefined {
+  const configPath = PHIO_HOME('config.json')
+  // console.log({ configPath })
+  const config = (() => {
+    try {
+      // console.log(`Reading config`, configPath)
+      return readJSONSync(configPath) as Partial<Config>
+    } catch (e) {
+      // console.warn(`${e}`)
+      return {}
+    }
+  })()
+  try {
+    if (v !== undefined) {
+      config[k] = v
+      // console.log(`Writing config`, config, configPath)
+      writeJSONSync(configPath, config)
+      return v
+    }
+    return config[k]
+  } catch (e) {
+    console.error(`${e}`)
+  }
+}

package/src/constants.ts

@@ -0,0 +1,22 @@
+import envPaths from 'env-paths'
+import env from 'env-var'
+import { ensureDirSync } from 'fs-extra/esm'
+import { join } from 'path'
+
+export const PHIO_HOME = (...paths: string[]) =>
+  join(
+    env.get('PHIO_HOME').default(envPaths(`phio`).config).asString(),
+    ...paths
+  )
+ensureDirSync(PHIO_HOME())
+
+export const PHIO_MOTHERSHIP_URL = (...paths: string[]) => {
+  const url = new URL(
+    env
+      .get(`PHIO_MOTHERSHIP_URL`)
+      .default(`https://pockethost-central.pockethost.io`)
+      .asString()
+  )
+  url.pathname = join(url.pathname, ...paths)
+  return url.toString()
+}

package/src/defaultInstanceId.ts

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from 'fs'
+
+export const defaultInstanceId = () => {
+  if (existsSync('package.json')) {
+    const pkg = JSON.parse(readFileSync('package.json').toString())
+    if (pkg.pockethost?.instanceId) {
+      return pkg.pockethost.instanceId
+    }
+  }
+  if (existsSync('pockethost.json')) {
+    const pkg = JSON.parse(readFileSync('pockethost.json').toString())
+    if (pkg.instanceId) {
+      return pkg.instanceId
+    }
+  }
+  return null
+}

package/src/getClient.ts

@@ -0,0 +1,17 @@
+import PocketBase from 'pocketbase'
+import { config } from './config'
+import { PHIO_MOTHERSHIP_URL } from './constants'
+
+export const getClient = () => {
+  const client = new PocketBase(PHIO_MOTHERSHIP_URL())
+  const { record, token } = config('auth') || {}
+  // console.log({ record, token })
+  if (record && token) {
+    client.authStore.loadFromCookie(token)
+    // console.log({ valid: client.authStore.isValid })
+    client.authStore.onChange((token, record) => {
+      config('auth', { token, record })
+    })
+  }
+  return client
+}

package/src/global.d.ts

@@ -0,0 +1,6 @@
+declare module 'fs-extra/esm' {
+  function readJSONSync(path: string): any
+  function writeJSONSync(path: string, data: any): void
+  function ensureDirSync(path: string): void
+  export { readJSONSync, writeJSONSync, ensureDirSync }
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env tsx
+import { program } from 'commander'
+import { LoginCommand } from './LoginCommand'
+import { version } from '../package.json'
+import { LogsCommand } from './LogsCommand'
+import { DevCommand } from './DevCommand'
+
+program
+  .name(`PocketHost CLI`)
+  .version(version)
+  .description(`CLI access to phio`)
+  .addCommand(LoginCommand())
+  .addCommand(LogsCommand())
+  .addCommand(DevCommand())
+
+program.parseAsync(process.argv).catch(console.error)