Download Chrome Video

[johnlindquist]

download-chrome-video.mp4

Open download-chrome-video in Script Kit

// Name: Download Chrome Video
// Description: Downloads the video of the current Chrome page
// Author: John Lindquist
// Twitter: @johnlindquist
// REQUIRES https://formulae.brew.sh/formula/youtube-dl

import "@johnlindquist/kit"
import Stream from "stream"

let writeableStream = new Stream.Writable()
writeableStream._write = (chunk, encoding, next) => {
    console.log(chunk.toString().trim())
    next()
}

cd(await path())

let url = await getActiveTab()

setChoices(null)
setDescription(`Downloading ${url}...`)
setInput(``)
setPlaceholder(`Please wait...`)

exec(`/opt/homebrew/bin/youtube-dl ${url}`, {all: true}).all.pipe(writeableStream)

[arthurdenner]

I installed youtube-dl with brew install youtube-dl and its path was different:

I've edited the script to use youtube-dl ${url}... and it seems to work.
@johnlindquist, could you confirm if it works for you and maybe update the gist?

Also, can we check if youtube-dl is installed and throw if it's not?
I didn't have it and it was failing silently. I tried to use exec('which youtube-dl') but it was throwing an error.

[johnlindquist]

Ah, looks like brew has different paths for different cpus: https://docs.brew.sh/Installation

That says Intel macs default to your path and Silicon macs default to mine. (I'm curious why they made that choice 🤔)

Looks like we can check if cpu is m1 or not like so then switch the path accordingly:

Open check-m1 in Script Kit

// Name: Check m1

import "@johnlindquist/kit"

import { cpus } from "os"
let isM1 = cpus()[0].model.includes("Apple M1")

await div(md(JSON.stringify({isM1})))

Re: "Check if youtube-dl is installed"- Yeah, I always debate how much of that logic to put in each script. Script Kit is made for developers who are comfortable with tweaking/writing scripts and tools like brew, so sometimes I avoid doing all those checks assuming the dev will figure it out. I'm may put together an API like:

await exec(`youtube-dl`, {
  onNotFound: ()=> {
    await div(md(`
## How to Install youtube-dl

1. Go to brew
2. etc...
`))
  }
})

Note: I would always recommend using the full path /usr/local/bin/youtube-dl to avoid any slowdown caused by path lookups. So many devs in our community have tools installed that can cause serious slowdown if you don't include the full path.

[arthurdenner]

Sounds fine to switch the full path according to isM1 to avoid slowdowns as you explained. 👍🏽
An API to handle errors would be great if it's not easy to handle as it is today instead of failing silently.

[johnlindquist]

Note: I would consider this "advanced" for a script

Note: I try to answer questions for people who land on this thread later who might be inexperienced with concepts like stdout/stderr/etc. I'm not making any assumptions about your knowledge level.

Failing silently comes from the way the stream is being handled to output progress to the console. It's not throwing an error because we're manually handling the stream of text. Removing the Writable code that logs progress would allow the script to properly catch the error. The way it is now, the all.pipe is sending "all" text to the same stream. It's important to remember that terminals and their tools are just "streams of text" no matter how advanced they may seem.

If we want to do both:

1. Send progress text stream to console
2. AND handle "errors"

then we'd have to split the stream into stdout and stderr and "catch" when stderr receives text. Please note, the terminal has no true concept of "Errors", it only sends text. Many CLI tools don't respect that stderr is meant to be used for errors, so we can't rely on this approach to work 100% of the time and it may need to be customized based on the CLI tool. I wish there was a way to write an API to properly handle all CLI tools, but

Open youtube-dl-is-missing in Script Kit

// Name: Youtube DL is Missing

import "@johnlindquist/kit"
import { Writable } from "stream"

// a helper for handling text stream
let toStream = fn => {
  return new Writable({
    write: async (chunk, encoding, next) => {
      await fn(chunk.toString().trim())
      next()
  }})
}

// lsx doesn't exist, so the child should send text "command not found"
let child = exec(`lsx ${home()}`)

child.stdout.pipe(toStream((text) => {
  console.log(text)
}))

child.stderr.pipe(toStream(async (text) => {
  // an example of "catching" an error and showing the user info
  if (text.includes(`command not found`)) {
      await div(md(`## Please Install youtube-dl

[https://formulae.brew.sh/formula/youtube-dl](https://formulae.brew.sh/formula/youtube-dl)
  `))
  }
}))

await div(md(`## Running non-existent command`))

[arthurdenner]

Thanks for a great explanation. Doesn't seem worth it to do all of it.
Just using a different path for non-m1 computers is enough?